Cream of the Crop 1/Cream of the Crop 1.iso/UTILITY/DOSIMP12.ARJ/SIMPLY3.HYP

Text File | 1992-01-16 | 117KB | 1,934 lines

                        |tMemory|t and Related Topics

First  of all,  |nmemory|n has  nothing to do  with disk space.   Some people
might call disk space "memory" but that is misleading and very confusing.
The two aren't related at all.   Disk space is where  the computer stores
things that it's not using at the moment.   Like a file cabinet.   |nMemory|n
is |TRAM|T (Random Access Memory)  chips that plug into the motherboard,  and
this is where  the computer keeps  programs that are  actually running at
the moment,  and the data  those programs are using.   Like your desktop.
The size of your desk and the size of your filing cabinets are not at all
related.   If you get an  "Out of memory" error,  don't be thinking  that
deleting files from your hard drive is going to help that.  What you need
to do  is remove  some of the |sTSR|ss  and |sdevice driver|ss that you're using.
The way to do that is to edit your CONFIG.SYS and AUTOEXEC.BAT files,  to
remove the commands  that start those |sTSR|ss  and |sdevice driver|ss,  and then
reboot the computer.  Or just reboot from a clean boo|1t disk.

Besides whatever programs you're working on,  and whatever |sdevice driver|ss
and |sTSR|ss your CONFIG.SYS and AUTOEXEC.BAT files loaded for you,  the com-
                       <page down> for more Memory
puter's |nmemory|n also contains the main parts of DOS, at all times.   With-
out DOS in |nmemory|n,  the computer is every bit as stupid  as your electric
stapler.   No, in fact,  more stupid than that  because the stapler knows
how to staple.   The computer doesn't know how to do anything  unless DOS
is there telling it.   This part of DOS that stays in |nmemory|n all the time
is called the DOS "|tkernel|t".  Now all the software companies know that the
DOS |nkernel|n has to be in |nmemory|n,  and even a couple  of |sdevice driver|ss and
|sTSR|ss too.  So when they write on the package that a certain program needs
512K or 640K in order to run, they mean you need to have that much |nmemory|n
installed, not that you need to have that much available.  By the way, to
find out how much you have available at any particular time,  look at the
last line of the CHKDSK command's output, or if you have DOS version 4 or
later, use the MEM command.

|nMemory|n is volatile.   That means it evaporates easily.   Ok, it's not the
|nmemory|n that's volatile,  it's the stuff that's in |nmemory|n that's volatile.
The second you turn off the computer,  or reboot,  or the power goes out,
everything  that was in |nmemory|n is gone.   And you can't get it back.   So
save your work to disk often.   For example,  as I'm writing this with my
                       <page down> for more Memory
word processor, the only place my words exist is in the computer's |nmemory|n
so if my  electric company hiccupped,  I'd have to start this chapter all
over again.  Well my word processor has this real handy F2 keystroke that
means  "save to disk under original filename".   So I hit my F2 key every
couple of sentences.  That writes my work to disk where it won't get lost
even if my electricity goes out altogether.   Of course your word proces-
sor doesn't  necessarily use the F2 key  for saving.   Find out what key-
stroke works to save data to disk in your word processor, and do it often
while  you're writing!   The same goes  for your  spreadsheet,  database,
paint program, and whatever other programs you use.

|tBytes|t are units of measurement for |nmemory|n.   A byte is just basically one
character of data.  "A" is a byte, "b" is a byte, "7" is a byte, "+" is a
byte, etc.  A bit is one eighth of a byte, and a nybble is one half byte,
but it's not too often  that you'll need to know those.   Mostly you only
need to know multiples of |nbytes|n, not fractions of them.   A Kilobyte, Kb,
or K, is 1024 |nbytes|n.  (The abbreviation Kilo usually means 1000, but com-
puters use a binary numbering system  so 1024 is what Kilo means when you
talk computers.)   A Megabyte,  Meg,  Mb,  or M,  is  1024 Kilobytes,  or
                       <page down> for more Memory
1,048,576  bytes.   And a  Gigabyte is  1024 Megabytes,  or 1,073,741,824
bytes.

There are lots  of different classifications of |nmemory|n.   The most impor-
tant is the lowest 640K, which is called |tConventional|t |nmemory|n.  That's the
kind that DOS knows how to run programs in,  and that's right, 640K of it
is all there is!   Well the designers  of the first PC thought that was a
good idea at the time.   See,  back then 64K  was a perfectly respectable
amount of |nmemory|n for a computer to have.   Honest,  you could run a whole
lot of programs in that little bit of |nmemory|n.   (You still could,  except
that programmers are writing  these big fat programs  with fancy graphics
and other  |nmemory|n-wasting features.)   All right,  so we started out with
the IBM-PC which didn't physically have  the ability to address more than
one meg of different |nmemory|n locations, and the designers had to set aside
some portion of that |nmemory|n space  to use for the |nmemory|n  on the graphics
card, and the BIOS,  and all that.   So they decided that 384K of the one
meg had to be |treserved|t for those things, and the other 640K could be used
as main program |nmemory|n.   And there wasn't anything wrong with that,  be-
cause remember computers back then didn't need any more than one tenth of
                       <page down> for more Memory
that!

Well nowadays we need more than that,  but we don't get it.   Because IBM
and Microsoft  are committed to  continued support  of the people who are
still using those IBM-PCs, |sXT|ss, and other computers that use the 8088 CPU
chip which can't address  more than one meg of |nmemory|n locations.   DOS is
never  going to lose the 640K barrier  as long as there are 8088 machines
still being used.

So,  what do we do about that  if we want  to keep using  DOS?   Well the
first workaround was  the |tExpanded|t |nMemory|n Specification,  which is called
|TEMS|T for short.   This scheme was invented  so that machines with the 8088
CPU could use more than  640K of |nmemory|n.   Well remember the 8088 can not
talk to more than  1,048,576 different  bytes of |nmemory|n.   But that's ok,
because remember that space  between the 640K  and 1024K addresses?   You
know,  the part  that's reserved  for the video card,  the BIOS,  and all
that?   Not all of that gets used up  by those things for which it is re-
served.   Some of it is  left empty.   So they invented  |nexpanded|n |nmemory|n.
There's a piece of hardware on an |nexpanded|n |nmemory|n board that knows how to
                       <page down> for more Memory
dynamically remap |nmemory|n locations into different |nmemory|n addresses.  Well
first it needs a certain piece of software loaded into |nmemory|n,  called an
Expanded |nMemory|n Manager (EMM),  that controls a certain 64K chunk of that
reserved |nmemory|n.  This 64K chunk is called a Page Frame.  Now the EMM can
use that  expanded  |nmemory|n board's  address remapping  ability  to switch
different chunks of expanded |nmemory|n in and out of that page frame.   See,
DOS can access  any |nmemory|n address  below one meg.   DOS normally ignores
everything above 640K because the rest is reserved, but the EMM tells DOS
that it's ok to look for data in the page frame.   So the EMM keeps track
of where the data is on the expanded |nmemory|n board,  and when DOS asks for
a certain piece  of data,  the EMM remaps  that piece of |nmemory|n  into the
page frame where DOS can see it, and then the next time DOS asks for some
other piece of data  from the expanded |nmemory|n board,  the EMM puts what's
in the page frame back onto the expanded |nmemory|n board  and gets the piece
DOS wants  and puts it  in the page frame  instead.   It's just switching
banks of |nmemory|n locations  into and out of  a small number of |nmemory|n add-
resses  (so EMS is also called  "bank switching").   As you can  imagine,
this goes a lot slower than normal conventional |nmemory|n access,  but it is
better than not having any way at all to access more than 640K of |nmemory|n.
                       <page down> for more Memory
(|sEMS|s is also called  |TLIM|T--Lotus-Intel-Microsoft--|nmemory|n,  and if you want
to buy an expanded |nmemory|n board, then make real sure  that it's complete-
ly hardware-compatible with version 4  of the |nLIM|n EMS specification since
a lot of programs won't be able to use it if it's not.)

But then came the 80286 processor.  This one has the ability to access 16
mega|sbytes|s worth of |nmemory|n addresses.  So a new scheme had to be developed
to access all those addresses!  This one was called |teXtended|t |nMemory|n Spec-
ification (|TXMS|T).   (Who came up with these names,  huh?)   Now there is a
problem with this.  The 286 processor can run in two modes.  One's called
|tReal Mode|t and that's the only one DOS can run in.  But in |nreal mode|n there
is no way to access anything  above the one meg address.   The other mode
is called  |tProtected Mode|t,  and in that mode  the computer can  address a
virtually unlimited  amount of |nmemory|n,  but DOS can't run when the compu-
ter is in |nprotected mode|n.   So you've got to have  a thing called  an |nXMS|n
manager, which is a device driver in the same way that the EMM is.   This
thing controls the processor's switching back and forth between |nreal mode|n
and |nprotected mode|n, so that |nextended|n |nmemory|n can be accessed.

                       <page down> for more Memory
Well  you can see  that with all this  switching of |nmemory|n  locations and
switching of  processor modes,  there's just about  no way that a program
can run in either expanded or extended |nmemory|n.  But there are quite a few
types of programs  that can store and access the data they're working on,
in those types  of |nmemory|n.   But these programs  have to be specially de-
signed to know  how to do that.   There's no way  to get a program to use
expanded  or extended |nmemory|n  for its data storage  unless it was written
specifically to be able to use it.

Besides just applications like some spreadsheets and databases, there are
other things  that very commonly know how  to use that additional |nmemory|n.
DOS  even comes with  a couple of them.   A RAMdisk can do it.   So can a
disk cache.   DOS comes with |sRAMDRIVE.SYS|s/|sVDISK.SYS|s  and SMARTDRV.SYS for
those purposes.  Print |sspooler|ss can also do it, but DOS doesn't come with
one of those,  except for the PRINT command  which is a spooler  that can
only use  conventional  |nmemory|n.   Most |sRAMdisk|ss,  disk caches,  and print
|sspooler|ss can even use extended |nmemory|n  without your loading any XMS mana-
ger!  They have their own built right in.  Isn't that convenient?

                       <page down> for more Memory
DOS versions 4 and 5 also come with |tHIMEM.SYS|t, an XMS manager, and an EMM
called |TEMM386|T.  As its name implies, |nEMM386|n can only run on 386 or higher
computers.  You see, a 386 doesn't need an expanded |nmemory|n board in order
to have expanded |nmemory|n.   The 386 processor has |nmemory|n-address-remapping
capabilities built right into it.   So all it needs  is the EMM (manager)
in order to treat  some of its extended |nmemory|n as expanded |nmemory|n.   This
is called EMS emulation.  This is not to be confused with EMS simulation.
Simulation is done on 286 machines that don't have expanded |nmemory|n boards
but it doesn't work nearly as well as real expanded |nmemory|n does.  The 286
just doesn't have the ability  to treat extended |nmemory|n as if it were ex-
panded.  An EMS simulator will try.   It puts the page frame into conven-
tional |nmemory|n instead of the reserved |nmemory|n area,  and it's slow, and it
can't even be used by some of the types of software that require expanded
|nmemory|n.  But if your application can use it,  and if you have the conven-
tional |nmemory|n  to spare to use  for the page frame,  it's better than not
having expanded |nmemory|n at all.  Pretty much.

So,  how do you remember the difference  between the words "|sexpanded|s" and
"|sextended|s"?   They're identical except for the middle syllable,  but it's
                       <page down> for more Memory
not really  so difficult.   The word  expanded  conjures up  the image of
something  that has gone  from being narrow  to being wide.   Well,  with
expanded |nmemory|n,  DOS is looking  through a  narrow page frame  at a wide
chunk of |nmemory|n.   The word extended refers to something going from short
to long.   And with extended |nmemory|n,  you take  the short list  of |nmemory|n
addresses that the computer can access,  just one meg,  and you make it a
long list of addresses,  up to sixteen megs or even more.   You could say
that description of extended could also apply to expanded, but it doesn't
because expanded |nmemory|n doesn't have any addresses.  (Except the 64K bank
of |nmemory|n that's  currently sitting in the page frame.   It has addresses
for the moment, but only until DOS wants data from one of the other banks
of expanded |nmemory|n  and the EMM swaps it back out  to the unaddressed ex-
panded |nmemory|n to swap the requested bank into the page frame.)

There are a lot more programs written  to be able to access expanded mem-
ory than there are of programs that can use extended.   Because it's been
around longer, so programmers have already learned real well how to write
for it.   And also because software companies  like to be compatible with
as many kinds of computers as possible to sell as many copies as possible
                       <page down> for more Memory
so they have to use expanded  instead of extended  so that their programs
will run on machines that are still using the 8088 processor.   But when-
ever you have  a choice of which kind to use,  go with extended if at all
possible because it's much more efficient!

One thing  that an  awful lot  of people  don't understand,  is that even
though extended |nmemory|n can't exist at any address lower than 1024K,  that
does not mean that a computer with  only one meg of |nmemory|n can't have any
extended |nmemory|n.   It doesn't mean that at all!   Remember, the addresses
between  640K  and 1024K  are reserved  for all that  BIOS and  video and
stuff.   So motherboard |nmemory|n  can't go there.   If you have  one meg of
|nmemory|n on your motherboard,  then the part above the first 640K has to go
into addresses above 1024K since it can't go into the reserved area.   If
someone is trying to sell you  a computer  that allegedly has  one meg of
RAM,  and it doesn't have either Shadow RAM or else 384K of extended mem-
ory, then he's trying to rip you off.   If you're getting one meg of mem-
ory addresses,  then you're only getting 640K of |nmemory|n, because all com-
puters have the empty 640K-1024K addresses,  even computers with only 32K
of RAM.   If you're getting one meg of |nmemory|n,  then you're getting 1408K
                       <page down> for more Memory
of |nmemory|n addresses.   The 640K-1024K  addresses are reserved.   They are
empty.   They don't have any |nmemory|n in them.   So they don't count as far
as "amount of |nmemory|n on the motherboard" is concerned.

Well those are the main types of |nmemory|n but we're not done with this les-
son yet.  Not at all.  For one thing, there are exceptions to some of the
rules I've given so far.   It actually is possible  to get more than 640K
of conventional |nmemory|n, even up to 736K.   But only on some machines, and
only if you give up your graphics capability.   Remember how there is all
that unused space in the reserved |nmemory|n area?   The only reason it can't
be used as conventional |nmemory|n is because it is not "contiguous", or in a
row, with the conventional |nmemory|n.   The lowest addresses in the reserved
|nmemory|n area  are used  by the graphics parts  of the |nmemory|n on your video
card.   So that is between  the conventional |nmemory|n  and the empty parts.
Since the  empty parts  are separated  from  the conventional |nmemory|n,  it
can't be part of conventional |nmemory|n.   But check this out!  The graphics
|nmemory|n is contiguous with  the conventional |nmemory|n.   If it weren't being
used for graphics, it could be used for conventional memory!  Well that's
just the idea behind programs such as Quarterdeck's VIDRAM.   It disables
                       <page down> for more Memory
the graphics and convinces DOS  to use that portion  of the reserved mem-
ory.  Absolutely amazing.   But of course you can't run any graphics pro-
grams while you're using VIDRAM.   Only plain old text programs like word
processors.  But just imagine being able to have over 700K of convention-
al memory!   You could have lots of |sTSR|ss loaded  and still be able to run
some really large programs.   Trouble with that is,  most of the programs
that want large amounts of |nmemory|n  are the programs that need to use that
graphics |nmemory|n for graphics.

So, besides disabling graphics to add it to the conventional |nmemory|n,  and
using 64K of it for an expanded |nmemory|n page frame,  how else can you take
advantage of the fact that the reserved |nmemory|n area is not all used up by
the things that are supposed to use it?  Well if you have the right hard-
ware and the right software,  you can run your |sTSR|ss and |sdevice driver|ss up
there which frees up  all the space  they would otherwise be  using up in
your precious conventional |nmemory|n.  What's the right hardware?  A 386, or
a 286 with a LIM 4.0 expanded |nmemory|n board,  or a 286 with a very special
chipset such as  the Chips & Technologies  NEAT chipset or just about any
one that has Shadow RAM capability.   (We'll get to Shadow RAM in a bit.)
                       <page down> for more Memory
All of these pieces of hardware have the ability to remap |nmemory|n from one
location to another.   So they can take some expanded  or extended |nmemory|n
and convince the computer that it's actually located in those unused add-
resses  in the reserved |nmemory|n area.   So now you have |nmemory|n that is not
in conventional addresses,  but is still in addresses  that DOS knows how
to communicate with.  And you can load things into those addresses.  What
is the software that you need  to make DOS use  those addresses  now that
you have |nmemory|n in them?   For a 286 there's Quarterdeck's QRAM, a couple
of other  commercial ones,  and even  two shareware ones  that I know of,
called  The Last Byte and HRAM.   For a 386  or higher computer,  there's
Quarterdeck's QEMM, Qualitas's 386Max, and even DOS 5.0's EMM386.   DOS 5
didn't include one for 286s  because there are so few 286s  that have the
|nmemory|n-remapping ability, whereas all 386s have it.

By the way,  once there is some |nmemory|n remapped into those empty reserved
|nmemory|n addresses, it's not called "|sreserved|s" anymore.   Now it's known as
|tUpper|t |nMemory|n Blocks.   Some software companies  even call it high |nmemory|n,
but I don't like to do that,  because it's too easy  to confuse that term
with the HMA.  (|TUMB|T is the abbreviation for |nUpper|n |nMemory|n Blocks.)
                       <page down> for more Memory
What is this  "|TBIOS|T" thing that  part of the reserved |nmemory|n  is reserved
for?  It stands for Basic Input/Output System.   This is the instructions
in the |nROM|n of the computer that tell it how to communicate with the peri-
pherals such as the drives, the keyboard, the comm ports, etc.  DOS talks
to the |nBIOS|n real often,  because each computer is a little different from
every other computer,  so DOS couldn't possibly  know how  to communicate
with every type of hardware.   So the |nBIOS|n is like the translator between
DOS and the hardware.   AMI and Phoenix  are both very popular  brands of
|nBIOS|n, and every make and model of computer has its own version.

Well,  considering how often DOS has to access the |nBIOS|n,  and considering
that it's in |TROM|T  (Read-Only  Memory)  which is non-volatile  and is very
slow,  wouldn't it be nice  to have it in fast RAM  instead of slow  ROM?
Well, that's what |tShadow|t RAM is all about.   Computers that can do |nShadow|n
RAM remap some extended |nmemory|n  into the reserved addresses through which
the computer would normally be accessing the |nROM|n,  and copy the data from
the |nROM|n into that remapped RAM.   So there you go, you have your |nROM|n |nBIOS|n
routines  in nice fast RAM  instead.   The problem is,  this is eating up
what would otherwise  be extended |nmemory|n.   Some computers only do it for
                       <page down> for more Memory
the addresses that are  used by ROM chips,  but others disable  an entire
384K  of extended |nmemory|n  while they're at it.   And some computers allow
Shadow RAM to be disabled,  so that your extended |nmemory|n becomes extended
again, but others don't.  So if you've only got one meg of RAM, then it's
possible that Shadow RAM ability  is depriving you of extended |nmemory|n al-
together.   Well, nothing in life is free.   You want fast BIOS routines,
but sometimes you have to give something up in order to get it.

Ok,  here comes another  exception to the rules.   I said that there's no
way that DOS can access anything above the one meg address.   Well that's
true,  DOS can't access  any block of |nmemory|n  whose starting  location is
above the one meg address.   But that doesn't say anything about the end-
ing location of a |nmemory|n block.  On a 286 or higher computer that has ex-
tended |nmemory|n, there's a little trick of the A20 address line that allows
DOS to access  a 64K chunk of |nmemory|n  that begins 16 bytes  below the one
meg address.   So that means  that 65,520 bytes  of that |nmemory|n block  is
above the one meg address, but DOS can access it because DOS names |nmemory|n
blocks by their starting address, not their ending address.   This little
64K chunk of space is called  the |tHig|1h|t |nMemory|n Area,  which is abbreviated
                       <page down> for more Memory
as |tHMA|t.   It's not conventional |nmemory|n,  because it's not contiguous with
the bottom 640K of |nmemory|n.   But some programs know  how to use it almost
as if it were conventional memory!   This is one of the best things about
DOS version 5.   It actually knows how to run  while part of it is in the
HMA!  You have to load the HIMEM.SYS device driver which is an XMS manag-
er and |nHMA|n manager, and then give the command |sDO|1S|s=|sHIG|1H|s in your CONFIG.SYS
file, and magically the DOS kernel and the BUFFERS will load into the |nHMA|n
instead of  into conventional memory!   This frees up  about 45K  of your
precious conventional |nmemory|n,  or even 64K of it  if you were using a lot
of buffers.   Also the latest version of  Microsoft's mouse driver can go
into the |nHMA|n.  But when one program is using the |nHMA|n nothing else can use
it.   Even if there is room left up there.    Nothing can go there except
things that the  controlling program  allows.   The DOS kernel allows the
buffers and the mouse driver,  but nothing else.   Any leftover |nHMA|n space
just goes to waste.




               <page down> for DOS 5.0's |nMemory|n Management
                       DOS 5.0's Memory Management

If you don't have  a 286 or  higher computer  with some  extended memory,
then don't even read this chapter.   It will only make you jealous of the
people who do have the right hardware to be able to do this stuff.

The first thing you want to do,  is load the  HIMEM.SYS device driver via
your CONFIG.SYS file,  by putting the line |sDEVIC|1E|s=C:\DOS\HIMEM.SYS at the
beginning of that file.  HIMEM.SYS is an XMS manager and HMA (|sHig|1h|s Memory
Area) enabler.  It gives you access to both of those types of memory.

Then add the line  |TDO|1S|T=|sHIG|1H|s anywhere in the CONFIG.SYS file,  and DOS 5.0
will load its kernel and the BUFFERS into the HMA instead of leaving them
to take up your precious conventional memory space.

Since the HIMEM.SYS device driver converts all of your extended memory to
XMS memory  (which just means extended memory  that's being managed by an
eXtended Memory Specification driver which is what HIMEM.SYS is),  if you
have  any programs  that can use  extended memory  but can't use  the XMS
                       <page down> for more DO|1S 5.0
method of accessing it, then you need to tell HIMEM.SYS to leave you some
plain old  extended memory  instead of managing all of it  and turning it
into XMS memory.   That's easy to do.   Just add the parameter /INT15=###
to the end of your  |sDEVIC|1E|s=|sHIMEM.SYS|s command.   The symbol ### stands for
however many Kilo|sbytes|s  of extended memory  you want to keep  as extended
instead of having it converted to XMS, plus 64K.  For example if you want
to keep 256K  of extended memory,  then you would use  /INT15=320 because
256 + 64 = 320,  so that will leave you with 256K of extended memory, and
the rest will still be converted to XMS memory and HMA and all that.

If you have a 286,  that's it,  you're done.   If you have a 386, there's
lots more, so read on!

First,  change DOS=|sHIG|1H|s to  DOS=|sHIG|1H|s,UMB which tells DOS to use the Upper
Memory Blocks that EMM386 is going to create.   And right after the HIMEM
.SYS line, you want to install EMM386.  If you just want EMM386 to create
some upper memory blocks  in the empty reserved memory addresses  between
640K and 1024K, then use this line:
          |sDEVIC|1E|s=C:\DOS\EMM386.EXE NOEMS
                       <page down> for more DO|1S 5.0
The NOEMS parameter tells EMM386 NOt to create any EMS (|sexpanded|s) memory.
So it will just remap some extended memory into those empty reserved add-
resses, so that it becomes upper memory.

If you want EMM386 to create upper memory  and also emulate some expanded
memory, then you use this line instead:
          |sDEVIC|1E|s=C:\DOS\EMM386.EXE #### |nRAM|n
The |nRAM|n parameter  tells EMM386 to create  upper memory  and also emulate
some expanded memory.  That means, take some extended memory and convince
the computer  that it's really expanded memory instead.   The #### symbol
there is the spot where you tell it how much EMS to create.   The default
is 256 so if you want  just 256K of  expanded memory,  then you can leave
that out.   If you want, say,  a meg of EMS,  then put 1024 there where I
put ####.   Now understand  that emulating EMS  is going to eat up 64K of
that upper memory that EMM386 has created for you.   Because that's where
the expanded |smemory|s's  page frame has to go.   That gives you 64K less of
upper memory that you can use,  so don't use the |nRAM|n parameter unless you
have an application that really does want some expanded memory.

                       <page down> for more DO|1S 5.0
(If for  some reason  you want to have  emulated expanded memory  without
creating any upper memory,  then load EMM386 without  either of the NOEMS
or |nRAM|n parameters.   And if for some reason you want to have upper memory
support without loading the DOS kernel hig|1h,  then use DOS=|sUMB|s instead of
DOS=|sHIG|1H|s,UMB.)

All right,  now you've got upper memory in what used to be empty reserved
memory addresses.   And you've used DOS=|sUMB|s to tell DOS to be prepared to
use that  upper memory.   So what do you do with it?   You load your |sTSR|ss
and |sdevice driver|ss into it!   So that they no longer take up any space in
your conventional |smemory|s!  For your |sdevice driver|ss, you just use the com-
mand |tDEVICEHIGH|t instead of the DEVIC|1E command you would normally use, and
make sure it comes after the commands  that load HIMEM and EMM386 or else
it won't work because there is not yet any upper memory to |nDEVICEHIGH|n in-
to.  For your |sTSR|ss, you insert the word |tLOADHIGH|t (or the abbreviation |tLH|t)
at the front of the command that loads the TSR into memory.  For example,
if you usually load a screen saver  with the command EXPLOSIV M2 then you
would change that to |nLOADHIGH|n EXPLOSIV M2 or |nLH|n EXPLOSIV M2 so the screen
saver will go into upper memory instead of conventional.
                       <page down> for more DO|1S 5.0
If you run out of upper memory  so that DOS can't load  the specified de-
vice or TSR there,  it will still load it,  but into conventional memory,
just as if you had used the DEVIC|1E command or left out the LH instead.

Now there are |sTSR|ss and |sdevice driver|ss that just won't run from upper mem-
ory at all.   No matter what.   And there are others that would run there
if only you could  get them up there.   Some of them  give a MEM  command
reading like as if they were small enough to fit into a free UMB, and yet
they will load into conventional RAM instead of loading high, as if there
was not enough memory free in the UMB.  A lot of times, all this means is
that there's not enough memory up there for it to load,  not that there's
not enough for it to run.  What?  Well you see, many drivers and |sTSR|ss re-
quire a whole bunch of memory while they're loading,  but then as soon as
they're loaded,  they settle down and only take up their normal amount of
memory.   If you've got one of these,  all you have to do is put its com-
mand earlier in the CONFIG.SYS or AUTOEXEC.BAT file, so that it loads be-
fore something else,  so that at that time,  there is a larger  UMB open.
Then it can load,  and it will settle down  to its normal small size,  so
that there will  still be room  for the one that you put  the misbehaving
                       <page down> for more DO|1S 5.0
one in front of.   So with DEVICEHIGH and LOADHIGH, loading order of |sTSR|ss
and |sdevice driver|ss matters even more than it used to before DOS 5.0.

The EMM386 |sdevice driver|s/command has a lot of switches and parameters but
you'll probably never need any of them, except the i switch.   The "i" is
for "include" and it lets you include extra upper memory addresses.   You
see, DOS only remaps extended memory to certain upper memory addresses it
knows  are available on  just about every type  of computer.   Almost any
computer has more available upper memory addresses than those,  it's just
that DOS has no way of knowing which ones are available,  unless you tell
it.   So if you can decipher the output of the MEM /D command,  or if you
have a program  such as Quarterdeck's  Manifest  that can tell you  which
addresses are not being used, you can use |sEMM386|s's i switch to tell it to
create usable  upper memory blocks in those addresses too!   Then you can
LOADHIGH a whole bunch more |sTSR|ss and |sdevice driver|ss!  For example, here's
the command I use in my CONFIG.SYS file:
          |sDEVIC|1E|s=C:\DOS\EMM386.EXE i=b000-b7ff i=c800-efff NOEMS
Because Manifest tells me that the addresses  B000-B7FF and C800-EFFF are
unused on my computer.  These addresses work for a lot of people.  But if
                       <page down> for more DO|1S 5.0
you want to try those, you make real sure to have a good |sboot|sable DOS 5.0
floppy disk handy before you add those i switches to your EMM386 command!
Because if those memory addresses are not available on your computer then
putting those switches in there could very well lock up your computer and
you won't be able to reboot either,  because every time you try, the com-
puter will read  the same line in the same CONFIG.SYS file  and just lock
up again!  You'll need to be able to boot from a floppy disk and edit the
CONFIG.SYS file to remove those i switches again.

Now there's  one problem  with having all that  free  conventional memory
that  DOS 5.0 can give you  when you load everything high.   In the past,
the  lowest 64K  of conventional memory  was always taken  up by  the DOS
kernel and stuff,  so programs never needed to know  how to run in such a
low address.  A lot of programs can't, but it never mattered before.   It
does now,  though.   Because with the DOS kernel and all your device dri-
vers and |sTSR|ss loaded high,  a lot of that lowest 64K of addresses is free
for program use,  and many programs just have a fit  when they try to run
there.   Common responses to this  are the  "|tPacked file corrupt|t" or "CRC
error"  messages,  or just not running at all.   What should you do about
                       <page down> for more DO|1S 5.0
it?  Either load a couple of |sTSR|ss low to fill up those lowest 64K of add-
resses,  or reboot the computer from a floppy disk that doesn't have DOS=
|sHIG|1H|s in its CONFIG.SYS file, or use the new command that comes with DOS 5
for just this purpose, whose name is |tLOADFIX|t.

Say you have a program named  HELLO.EXE that gives you that  "Packed file
corrupt" message when you try to run it.   Well all you have to do is in-
stead of typing  HELLO to run that program,  just type  |nLOADFIX|n HELLO and
|nLOADFIX|n will load the  HELLO.EXE program into addresses  above the bottom
64K, and run it there.  Then it'll work just fine.

Now if you have a 386 computer,  with DOS 5.0,  you should be able to get
about 616K  of free conventional memory.   The only things that should be
loaded low are parts of MSDOS, HIMEM, EMM386, and COMMAN|1D.  Hopefully you
will be able to get everything else into the upper memory blocks.

If you have a TSR that allows you  to use commands to modify its behavior
after it's loaded, and you used LOADHIGH to load it,  you may have to use
LOADHIGH to get the modifying-commands to work also!  For example, I have
                       <page down> for more DO|1S 5.0
a screen saver named EXPLOSIV and it allows commands such as EXPLOSIV OFF
to temporarily disable it, EXPLOSIV ON to re-enable it, etc.  Well when I
have it |sLOADHIGH|sed,  those commands don't work.   Because, when I use the
OFF parameter to try to disable it, EXPLOSIV loads into conventional mem-
ory and looks around  to find the copy of it that's already loaded to try
to disable itself, and it finds that it's not already loaded,  so how can
it disable itself?  It is already loaded, but it can't tell that, because
it is only looking for itself in conventional, not upper, memory.  So the
command LOADHIGH EXPLOSIV OFF works,  because with that command, EXPLOSIV
loads into upper memory to look for the already-loaded copy of itself and
turn it off.   It works just fine that way.   It seems strange to use the
LOADHIGH command to disable a TSR,  but in some cases  that's what has to
be done.  So if you have a TSR that lets you disable it, or unload it, or
modify it in some way,  and it doesn't work  when the TSR is  |sLOADHIGH|sed,
try using the LOADHIGH command like that, and it just might work for you.

Be sure to use the versions of HIMEM.SYS  and SMARTDRV.SYS that came with
DOS 5 rather than the old outdated ones that came with Windows 3.0 if you
use Windows!
                      <page down> for What Is a TSR?
                              What Is a |tTSR|t?

|nTSR|n stands for Terminate-and-Stay-Resident.  Another name for |nTSR|n is Mem-
ory-Resident-Program.   That means any program  that you load into memory
once, and it stays there,  at your beck and call,  or just hanging around
in the background  watching every move  you make,  until such time as you
reboot the computer.

DOS itself can be thought of as a |nTSR|n,  except that TSRs  are usually op-
tional,  and DOS is not.   If you don't have DOS  resident in memory then
your computer  ain't going  nowhere!   |sDevice driver|ss  are also TSRs in a
way, but just a special type of |nTSR|n.

If you have a mouse or trackball,  and you load its driver  via AUTOEXEC-
.BAT rather than CONFIG.SYS,  then it is not  a device driver exactly but
it still is a |nTSR|n,  most definitely.   It hangs around  in the background
watching you, and whenever you move your mouse it springs into action and
moves the mouse pointer around on your screen.

                         <page down> for more TSR
Automatic screen savers  that blank your screen after a certain number of
minutes of keyboard inactivity are TSRs.   Anything you can "hotkey" into
with a little keystroke combination like <Ctrl-Esc> or <Alt-F1> is also a
|nTSR|n.  There are lots of little phone book and appointment scheduler TSRs.

And here are some of the TSRs that come free with DOS:   APPEND,  DOSKEY,
DOSSHELL, FASTOPEN, GRAPHICS, MIRROR, MODE, PRINT, and SHARE.  Except for
DOSSHELL  and MIRROR,  once you execute those commands,  the |nTSR|n stays in
memory until you reboot.   Some TSRs have commands  that remove them from
memory, but not most of the ones that come with DOS!  Although there is a
great public domain utility called Mark-and-Release (and some others that
work in the same manner)  that you can use to make it possible  to remove
just about any |nTSR|n from memory without |sreboot|sing.

Of course it's not possible to remove one |nTSR|n if there has been any other
|nTSR|n loaded into memory after it.  The only thing you can remove from mem-
ory is the most recent thing you put into memory.  Strangely enough, this
includes batch files.   If you issue a command  to remove a |nTSR|n from mem-
ory from within a batch file, that |nTSR|n won't drop out of memory until the
                         <page down> for more TSR
batch file ends.  Because although a batch file isn't actually loaded in-
to memory  while it is executed,  there is some |sbatch|s-file-handling data,
that does take up a speck of memory while the batch file is running.   So
the batch file  that gives the command  to unload the |nTSR|n might cause the
|nTSR|n to be disabled and not work anymore,  but the memory that the |nTSR|n was
using won't be freed up for other uses until that batch file exits to the
DOS prompt.

You mustn't ever try to load or unload a |nTSR|n from within another program,
such as when you're shelling out  from your word processor  or something.
You have to exit  to the primary command processor  before you can do any
messing around with  memory allocations,  or you'll probably  lock up the
whole computer and be forced to reboot,  losing whatever data you had en-
tered into your application since the last time you saved it to disk.

TSRs eat memory.   They eat it for breakfast, lunch, and dinner.   If you
have any "Out of |smemory|s" errors,  the first thing  you want to do is make
sure you're not using  any TSRs or |sdevice driver|ss in  your CONFIG.SYS and
AUTOEXEC.BAT files, except necessary ones.  (See also LOADHIGH.)  The DOS
                         <page down> for more TSR
version 4  installation program  puts a whole bunch  of worthless  things
like APPEND, FASTOPEN, GRAPHICS, and PRINT into those files.   Get rid of
them,  unless you have read  what they're about  and still think you need
them.   (In fact,  if you have DOS 4,  check out  every command  in those
files because  there are other  useless ones  like |sLASTDRIVE|s=E and VERIFY
OFF  which are |sdefault|ss,  and  |sBREAK|s=ON  which slows  your computer down.
These don't take up any memory, but they're still worthless and should be
removed.   I can't imagine  who wrote that ridiculous  DOS 4 installation
program, but it sure wasn't anyone who knew anything about DOS commands.)

If you have DOS version 4 or later,  you can use the MEM command  to find
out  what TSRs you  have loaded.   Otherwise,  look and see what kinds of
commands  you have in  your CONFIG.SYS  and AUTOEXEC.BAT files.   The DOS
commands you can look up right here to see if they're TSRs,  and the non-
DOS commands you will have to check the documentation that came with each
program.   Now you know what TSRs get loaded from your AUTOEXEC.BAT file,
and then there could also be  others that you've loaded  since your AUTO-
EXEC.BAT file  was run at |sboot|sup.   For example,  let's say you don't use
the PRINT command  in your  AUTOEXEC.BAT file  because you don't  need it
                         <page down> for more TSR
that often.   But the PRINT command  is still a |nTSR|n every time you do use
it,  regardless of whether your AUTOEXEC.BAT or your fingers typed in the
command.

Another thing that a lot of new computer users don't realize, is that the
DOSSHELL  and most other menu programs  are TSRs.   There are  some menus
that drop most of the way out of memory when you launch a program through
them, but most of them, including the DOSSHELL,  stay right there in your
memory,  in the way of your  programs that you're  trying to run.   Isn't
that dumb?  You have to exit out of the DOSSHELL or menu program in order
to have enough memory  to run a program,  so what good does it do to have
the menu, right?  Just to remind you of what programs you could run?  You
can get that from the DIR command!

Even worse than that,  many menu programs allow shelling out to DOS,  but
they don't tell you that you're supposed to type EXIT to get back in,  so
instead,  you type the command that starts the menu.   Know what you just
did?   You just loaded  a second copy  of the menu program  on top of the
first copy that was already there!  Now you're really wasting |smemory|s!  Be
                         <page down> for more TSR
careful with menu programs.  They can really cause all sorts of problems.
But if you know what shelling out is about, you can avoid those problems.

There are lots  of occasions  when you need to  absolutely  and without a
doubt boot up without any TSRs whatsoever.   For example, when you're in-
stalling a new software package  you just bought,  or every time  you are
about to run a disk optimizer  to take care of all your fragmented files.
The easiest way to do that,  is to reboot  from a boo|1t disk that was for-
matted with the /S switch, and that doesn't have any AUTOEXEC.BAT or |nCON|n-
FIG.SYS files on it.  You can put those files on your boo|1t disk, but only
if the CONFIG.SYS file  doesn't contain anything  except your hard disk's
device driver  if your hard disk needs one,  and only if the AUTOEXEC.BAT
file doesn't contain anything but PATH and PROMPT and C|1:.  Now you have a
boo|1t disk  that is safe to use  whenever you're going to  defragment your
hard drive or install some new software.  This is necessary because real-
ly bad things can happen if you have any TSRs in memory while you perform
such operations.  Especially the disk optimizer.   It's going to move all
your files  to different parts of the disk.   Well if there's anything in
memory like a disk cache,  or FASTOPEN,  or anything that  keeps track of
                         <page down> for more TSR
where the data is at on the disk,  well,  when the optimizer moves every-
thing around,  then those TSRs are going to have the wrong info, and they
are going to trash your entire FAT.  Or if you have any |nTSR|n that gets ac-
tivated at a certain time, or after a certain delay, and it comes to life
just as the optimizer is writing to the FAT, whoa, look out!  And then to
really be on the safe side, reboot the computer again the very second the
optimizer finishes!  That will remove everything from memory  and let the
TSRs read  the changed information  from the disk again,  in case you had
forgotten to remove any of them.

TSRs work by trapping a certain interrupt.   For example, a pop-up sched-
uler might sit there waiting for you to press the <Alt-S> keystroke.  Now
if you have another |nTSR|n that grabs the interrupt for that keystroke also,
or if the application you're working on uses that keystroke,  then you've
got a |nTSR|n conflict.   There are a whole lot of ways that one |nTSR|n can con-
flict with another, or with a program.  So whenever you start using a |nTSR|n
that you've never used before,  watch out for problems, and if any occur,
it's probably the fault of your new |nTSR|n.   There ain't no such thing as a
free lunch,  ya know,  so along with the convenience of pop-up schedulers
                         <page down> for more TSR
and other highly  useful TSRs,  you've got to  expect some  problems too.
Most TSRs work just fine  all by themselves,  but when you go using  more
than one at a time,  there could be trouble.   I've been lucky,  and only
had problems with two or three TSRs in my life,  but I know people who've
had major problems  with lots of them.   It just depends  on what sort of
system you have,  what other TSRs you use, and what applications you run.
It also depends a lot on what order you have the different TSRs installed
in your AUTOEXEC.BAT file.   If |nTSR|n-A doesn't work right when it's loaded
before |nTSR|n-B,  then switch those AUTOEXEC.BAT lines around  to load |nTSR|n-A
after |nTSR|n-B instead, and it might work just fine, believe it or not!

Many TSRs (and a lot of games too)  take over the system clock (|sCLOCK$|s) a
bit more selfishly than they ought to, and end up ruining the time and/or
date that DOS thinks it is.   If you find that  you have  such a program,
you want to remember  to reset the TIME  every now and then,  so that the
time  in your directory listings  stays close to correct.   You can use a
batch file to help you remember to do that.

This looks like  a good time  to tell you  the safe way  to install a new
                         <page down> for more TSR
program, whether it be a |nTSR|n or not.   First, never install more than one
new program in a day.  Because if you do, and problems occur, you have no
idea which program  went wrong.   Install one,  test it for a day  or so,
then install the next one.  And never install a program without a BACKUP.

Before you  install anything,  reboot the computer  with no TSRs  loaded.
Using an |nINSTALL|n command  with TSRs in memory  can make the  installation
program screw everything up.  Read the program's documentation, especial-
ly the installation and troubleshooting chapters, and any README.TXT type
files that came with the program.  README.TXT files are generally full of
information  that the publishers  didn't remember  until after the manual
was printed, so you don't want to miss it!  Now run the program's |nINSTALL|n
command and try out the new program.   If it works ok, reboot your compu-
ter with your normal CONFIG.SYS and AUTOEXEC.BAT files,  and test it some
more.   If there are any problems,  then "|sREM|s out" the |sdevice driver|ss and
TSRs from those startup files,  and try again.   Remove the REM  from one
line at a time, reboot,  test the program again,  remove the REM from an-
other line, reboot, test, etc., until you discover which device driver or
|nTSR|n is conflicting with your new program.   Try changing the order of the
                         <page down> for more TSR
command  that loads that driver or |nTSR|n,  try it again, etc.   If your new
program just absolutely  will not run with  that |nTSR|n or driver,  then you
have to make up your mind which one you'd rather give up.

Now besides  installing new software,  and using a disk optimizer,  other
times when it's very important to remove all your TSRs and |sdevice driver|ss
from memory,  are when you're about to use any BACKUP or RESTORE program,
or any sort of disk structure repair program like PC Tools's DISKFIX com-
mand or CHKDSK with the /F switch.










                     <page down> for The |nMEM|n Command
                             The |TMEM|T Command

Don't you hate the way you have to use the CHKDSK command and wait for it
to finish looking at your disk, in order to find out how much free memory
you have at the moment?  Well if you have DOS version 4 or later, there's
no need to use CHKDSK for that purpose anymore!  That's what the |nMEM|n com-
mand is for.

Not only does it tell you how much memory is currently free,  it can also
tell you a whole bunch of other information if you ask it to real nicely.

You can use |nMEM|n all by itself or with the /P, /D, or /C switches, and |nMEM|n
will tell you a different amount of information depending on which switch
you use.   The /C switch is the one you want to use if you have DOS 5 and
you want to see what's going on in the upper memory blocks.

If the |nMEM|n command  doesn't report  anything about EMS memory,  then that
means that  either you don't have any expanded memory,  or else that your
expanded memory is not LIM 4.0 compatible.   |nMEM|n won't say anything about
                         <page down> for more MEM
extended memory either, if you don't have any of that.

|nMEM|n is one command that you don't want to execute while shelling out from
the DOSSHELL.   It doesn't give you the correct results.   For one thing,
you have the DOSSHELL  and a secondary COMMAND.COM shell in memory.   For
another thing,  the |nMEM|n command is going to tell you  that you don't have
any available XMS memory even when you do,  if you're inside the DOSSHELL
at the time.

If you have DOS 4 the /C switch doesn't exist, and the /P and /D switches
can't be abbreviated.  Their real names are /PROGRAM and /DEBUG.








                      <page down> for What Is CMOS?
                              What Is |TCMOS|T?

If you have a 286 or newer computer, you probably have |nCMOS|n.  What is it?
Complementary  Metal  Oxide  Semiconductor.  Now please don't ask me what
that is supposed to mean,  I just thought you'd like to know what the in-
itials stand for.

What does it do?  Well it's a little piece of memory that is backed up by
a battery, that keeps track of the date and time, as well as what sort of
hardware you have installed in your system.   The amount of RAM, the num-
ber and types  of floppy drives,  the number of hard drives  and detailed
information about each,  the type of graphics adapter, the number of ser-
ial and parallel ports, all this information is stored in |nCMOS|n.   If your
|nCMOS|n gets wiped out,  your computer won't even know  that you have a hard
drive, but you might be able to boot from a floppy disk.

So may I suggest  that you quickly get into  your CMOS's |tsetup|t  and write
down every detail of what it says, because some day your battery is going
to run down  and the |nCMOS|n information  will all be lost,  so you'd better
                        <page down> for more CMOS
know what information is supposed to be there so you can put it back!

The way to get into the |nCMOS|n is a little different for each type of BIOS,
but for mine,  a little message comes up on the screen  every time I turn
on the power, which says something like, "Press |nDEL|n to enter |nCMOS|n |ssetup|s".
If I press the <Delete> key while that message is on the screen, then af-
ter a couple seconds I get the |nCMOS|n setup screen.   I'm sure that if your
screen doesn't give you any such message,  then the manual that came with
your computer will tell you what to do to get to your |nCMOS|n setup.

Just write down  whatever it says there,  be sure not to change anything,
and then exit.   Keep that information that you wrote down in a very safe
place, and whenever your battery dies,  just get a new one, and you'll be
able to put the correct information back into the |nCMOS|n.

You also have to get into the |nCMOS|n  each time you install a floppy drive,
or more memory, so that you can tell your computer that its configuration
has changed.

                     <page down> for What Is the CPU?
                             What Is the |TCPU|T?

The |nCPU|n is the computer's brain.   It stands for Central Processing Unit.
It is just a little square chip about an inch and a half on each side, if
you can  believe that,  and that's where  all the computing  takes place.
The one for the first set  of personal computers was the |T8088|T,  which was
put into an IBM computer model which was named the PC,  and also the next
model, which was called the |TXT|T.   There is also an 8086 processor,  which
is very much like the |n8088|n but more expensive, so it was not widely used.
Neither of those can in any way access  memory above the one meg address,
but it can use expanded memory.   After that came the 80286 |nCPU|n, which is
usually abbreviated as |T286|T.   This was the first computer that could take
advantage of extended RAM.   It went into a model of computer  called the
|TAT|T.   After that, the |T386|T and 486, now even 586, came along.   Who knows,
by the time you read this,  there could be an 80686 processor being made!

When someone talks about  an |n8088|n, he could be just  making a generaliza-
tion, and he's really  talking about an |n8088|n or 8086.   Also, when a body
talks about an |nAT|n, he could be talking about a |n386|n as well as a |n286|n.
                         <page down> for more CPU
Now when it comes to the 386 |nCPU|n,  you'll often hear talk of an  SX and a
DX.   Well a 386DX is just a normal 386.   It processes data 32 bits at a
time, and it talks to other parts of the computer 32 bits at a time also.
A 386SX is just like a 386DX,  but it can only talk to other parts of the
computer 16 bits at a time.   Because the SX's  bus is only 16 bits wide.
The bus is  the data |npath|n  from the |nCPU|n  to other parts  of the computer.
The effect that the 16-bit bus of the SX has,  is that it's just a little
bit slower than the DX,  and that it doesn't have enough address lines to
be able to talk to as many memory locations.  So an SX can only deal with
16 mega|sbytes|s of memory, just like the 286.

A 486 can do everything a 386 can do, only lots faster.   It has a built-
in math coprocessor (unless it's a 486SX) and a built-in memory cache.

How about a little chart?




                         <page down> for more CPU
         |nCPU|n          Processor        Bus         Maximum |nMemory|n

         |n8088|n          16-bit          8-bit         1 Megabyte
         8086          16-bit         16-bit         1 Megabyte
        80286          16-bit         16-bit        16 Megabytes
        80386SX        32-bit         16-bit        16 Megabytes
        80386          32-bit         32-bit         4 Gigabytes












                     <page down> for What Is a Cache?
                             What Is a |tCache|t?

There are three different kinds of |ncache|n.   The most common one is a hard
drive |ncache|n,  and that is a piece of software which,  when you install it
into memory,  sets aside a large chunk  of extended or expanded memory to
do the caching.   Now what it does,  is every time you read something off
the hard drive,  it keeps it in  this chunk of memory,  and then when you
need that piece of info again,  you get it from the |ncache|n which, since it
is in RAM,  is a lot faster than going back to the hard drive to get that
piece of data again.   The |ncache|n that comes  with recent  versions of DOS
is called SMARTDRV.SYS.  And it's pronounced "CASH", not "cash-AY".

Most caches also do what's called look-ahead, which means that every time
you get some data  from the hard drive,  it also gets the next one or two
|ssector|ss of data, and puts that in the |ncache|n also.  So if you're running a
type of program that does a lot of sequential disk access,  then the next
time the program needs more data,  it's probably already in the |ncache|n be-
cause the next  data it needs  is what came right after  the last data it
needed, which the |ncache|n already looked ahead to get.
                        <page down> for more Cache
Even though BUFFERS do the same thing a |ncache|n does, only not as well, you
do need to have some buffers even if you have a |ncache|n because most caches
don't pay any attention to floppy drives.  They only work on hard drives.
Well the buffers  will do a little bit  of caching  with the floppy drive
info.   And one more reason for buffers even with a |ncache|n,  is that some-
times you need  to disable the |ncache|n,  like when you're about to optimize
your hard drive  (that means fix the fragmented files).   If the |ncache|n is
disabled for a while,  you'll be glad that you have a few buffers loaded.
But I do mean just a few,  because with a |ncache|n, the memory that having a
lot of buffers  takes up,  is not worth it.   Unless  you've never  had a
shortage  of conventional memory  in the first place,  or if you have DOS
version 5,  where buffers go into the hig|1h memory area  and don't take up
any conventional RAM anyway.

Now one thing  you need to remember.   You'd think  that if a large |ncache|n
is good, then a huge |ncache|n would be even better, right?  Wrong.   A |ncache|n
that's too large  slows things down instead of speeding them up,  because
looking through all that data  that's stored in the |ncache|n can take longer
than it would have taken  to just get the data  from the hard drive!   So
                        <page down> for more Cache
pay attention to the manual for your |ncache|n program, and if it says a cer-
tain size  is recommended,  then use that size  until you know more about
the subject  and have some spare time  to go testing things with a bench-
mark program to find out the optimal |ncache|n size for your system.

There is one thing to watch out for with a disk |ncache|n, though.   Remember
that the information  in the |ncache|n is just a copy  of what's on the disk.
Just because the CHKDSK command tells you that your hard drive is trashed
does not necessarily mean that it's true!   Suppose you're playing around
with trying to load  a new TSR  into upper memory.   Something goes wrong
and the |ncache|n in the extended memory gets trashed, and then for some rea-
son you use the CHKDSK command  and it says your hard drive  has no files
on it, only a million lost chains in a zillion lost |scluster|ss.  Well don't
panic!   It's quite likely that when  CHKDSK went to check your directory
structure for you,  it found the information that it thought it was look-
ing for, in the |ncache|n so it didn't even look at the hard drive.  The copy
of the directory structure that was sitting in the |ncache|n has been corrup-
ted so CHKDSK  just thinks your disk  is trashed,  but there's really not
a thing wrong with your hard drive at all.
                        <page down> for more Cache
So remember,  if CHKDSK  ever tells you  that your whole disk  is trashed
while you have a disk |ncache|n active,  flush or disable the |ncache|n  and then
try again  to read your hard drive.   I'll bet you'll find that it's just
fine.   Just get rid of whatever it was that you were trying to load into
your extended or upper memory that trashed your |ncache|n information.

The second type of |ncache|n is  a hardware drive |ncache|n that's located on the
hard drive controller.   It does the same thing as the software one, only
it doesn't take up any of your conventional, extended,  or any other type
of memory.   The memory that it uses is built right in to the controller.
It's usually  pretty small though,  so you  probably want to  use a small
software |ncache|n along with it  if you have the memory to spare.   But then
you probably won't have to worry  about such things,  because controllers
that have built-in |ncache|n cost a fortune!  You most likely don't have one.

The other type  of |ncache|n  is a RAM |ncache|n,  which is just a small chunk of
super-fast memory.   It performs the same function for the memory as what
a hard drive |ncache|n does for the hard drive.  It sure speeds things up!

              <page down> for The |nSMARTDRV.SYS|n |nDevice Driver|n
                      The |tSMARTDRV.SYS|t Device Driver

This is the disk cache that comes with  DOS versions 4 and up.   Ok, it's
not the greatest  disk cache in the world,  at all,  but if it's the only
cache you've got, it's a good one.   You install it, like all device dri-
vers, with a DEVIC|1E or DEVICEHIGH command  in your CONFIG.SYS file.   You
have to have a hard drive, and extended or expanded memory to use it.  If
you have both those types of memory,  use extended (unless you have a lot
more expanded memory to spare than you have of extended |smemory|s).  Because
it's more efficient.

Here's the syntax for this device:
          |sDEVIC|1E|s=C:\DOS\SMARTDRV.SYS #### /A
And that assumes,  of course,  that your |nSMARTDRV.SYS|n file  is in the DOS
directory on your C: drive.   The /A switch  means that the cache will go
into expanded memory.   Without the /A,  it will go into extended memory.
The #### parameter  is the size of the cache in kilo|sbytes|s.   Legal values
are from 128 to 8192, with the default being 256, and that's about as low
as you should go.  If you don't have as much memory as you specified, the
                    <page down> for more SMARTDRV.SYS
cache will load anyway,  and just use  whatever memory  you do have.   Of
course the  DEVIC|1E  command  has to appear  later in CONFIG.SYS  than the
extended (|sHIMEM.SYS|s) or expanded memory manager,  or else the cache won't
have any usable memory to go into!

Do not ever,  ever,  ever  use a disk optimizer  (a program that fixes up
fragmented files)  with a cache active!   That includes FASTOPEN,  SMART-
Drive,  or any other sort of cache.   If you do,  you may as well get out
your set of BACKUP disks because your FAT is going to get trashed.

Keep your  BUFFERS command  at 20 or lower  when you're using SMARTDrive,
and definitely do not use any look-ahead |ssector|ss (that's the part you can
use after a comma on the BUFFERS command).






                    <page down> for What Is a RAMdisk?
                            What Is a |tRAMdisk|t?

The way to get one of these is just to load the |tRAMDRIVE.SYS|t (for MS-DOS)
or |tVDISK.SYS|t (for PC-DOS) file as a device driver in your CONFIG.SYS file
and then reboot.  Well, now that you have a |nRAMdisk|n, what on earth is it?

A |nRAMdisk|n is  a chunk of memory  that has been made to act  like a floppy
disk drive,  only a really fast floppy disk drive!   Because it's  only a
chunk of RAM instead of a mechanical disk drive,  the access time is just
the same  incredibly low number  as the access time for your RAM.   Other
than that, you can use it just exactly the way you'd use a disk.   A |nRAM|n-
disk is also known as a |tVirtual Disk|t.

The only thing you have to remember, though, is that the |nRAMdisk|n still is
made of RAM, even if it is acting like a disk drive, so if the power goes
out,  everything that was on the |nRAMdisk|n is gone forever!   You've got to
remember that anything  that's on the |nRAMdisk|n that gets changed,  edited,
or updated,  has to be saved to disk before the power is shut off, or be-
fore some lightning shuts the power off for you, or before you |sreboot|s!
                       <page down> for more RAMdisk
It's best to use a |nRAMdisk|n only for files that don't get changed, such as
your favorite utilities  and DOS command files.   If your hard drive does
not have  an access time under 20ms,  then you'll be absolutely amazed at
how much faster  a batch file works if you run it  from a |nRAMdisk|n instead
of from the hard drive.   Just put your |nRAMdisk|n  at the very beginning of
the PATH command in your AUTOEXEC.BAT,  so that DOS will look there first
for all your commands.  If you don't do that, then DOS will find the com-
mand file on your hard drive first, and run it from there, so it won't be
doing you any good to put the files onto the |nRAMdisk|n.

How do  you get  all your  favorite command files,  utilities,  and batch
files onto the RAMdisk?   You just use COPY commands in your AUTOEXEC.BAT
file, like this, assuming your |nRAMdisk|n is drive letter F:
          COPY C:\DOS\CHKDSK.COM F: > NUL
          COPY C:\DOS\FORMAT.COM F: > NUL
          COPY C:\DOS\FIND.EXE F: > NUL
          COPY C:\BELFRY\MENU.BAT F: > NUL
The reason for the " > |sNUL|s" at the end of each line is because the output
of each COPY command is going to be a "1 file(s) copied" message, and you
                       <page down> for more RAMdisk
don't want to be seeing that every time you boot your computer.  NUL is a
special imaginary device that DOS uses.   It basically means,  "nowhere".
(See also Redirection.)

A |nRAMdisk|n just gets  the next higher letter,  after all the drive letters
your system already has.   If you already have an E: drive,  your |nRAMdisk|n
will get the letter F:.   Don't forget that  the default LASTDRIVE is E:,
so if  your |nRAMdisk|n is going to  give you a higher letter than that,  you
need to raise your LASTDRIVE by putting a statement like |sLASTDRIVE|s=F into
your CONFIG.SYS file.   Otherwise DOS won't be able to recognize what you
mean when you type F: to refer to your |nRAMdisk|n.

Another type of file  that it's really good to put on a |nRAMdisk|n,  is temp
files.   These are temporary files  that get created by some applications
and then deleted by the same application when the app no longer needs it.
If the instruction manual  for the app says that you can tell it where to
put its temp files,  then tell it  to put them  on a |nRAMdisk|n.   That will
make  your app run a lot faster  than it would  if it were using the hard
drive instead of the |nRAMdisk|n, for its temp files.   Don't worry about the
                       <page down> for more RAMdisk
fact that the |nRAMdisk|n will lose all its data if you have a power failure.
Because even if the temp files were on the hard drive,  if the power went
out,  the application would have lost its place  in the temp file anyway,
and the temp file would now be useless to the app and you would just have
to delete it to free up the space it was taking up on your disk.   So you
don't lose anything  by having the temp files on the |nRAMdisk|n if the power
goes out.   You've just saved yourself from  the trouble of finding those
leftover temp files and deleting them.

If you have any extended memory,  then a |nRAMdisk|n is  one of the best uses
for it!   The RAMDRIVE.SYS and VDISK.SYS |sdevice driver|ss contain their own
extended memory managers, so you don't need any special software in order
for your |nRAMdisk|n to be able to use your extended memory.  Just add the /E
switch to the end of that DEVIC|1E command in CONFIG.SYS,  and your |nRAMdisk|n
will be placed  into extended memory  instead of taking up space  in your
conventional memory.  (With DOS 5 you do have to load HIMEM.SYS first.)

If you have  a recent DOS version,  you can also place  your |nRAMdisk|n into
expanded memory,  if you don't have any extended memory (|sextended|s is more
                       <page down> for more RAMdisk
efficient),  by using the /X or /A switch.   Which one is allowed, if ei-
ther, depends on the DOS version that you have.

Here is the complete syntax for the  RAMDRIVE.SYS and  VDISK.SYS drivers:
          |sDEVIC|1E|s=D:\DIR\FILENAME.SYS AAAA BBB CC /E:D /X:D /A:D
where AAAA is  the size of the |nRAMdisk|n  in Kilo|sbytes|s,  and the default is
64.   The BBB parameter stands for  the |ssector|s size  you want the |nRAMdisk|n
to have.   The choices are 128, 256, and 512, with 128 being the default,
except for DOS version 5 where the default is 512.  Just use the default.
The CC parameter means  the number of root directory entries you'll need.
The default is 64,  so if you're hard up  for space on your |nRAMdisk|n,  and
you're only going to need a few files at a time, give a smaller number so
that less |nRAMdisk|n space will be occupied by the directory.  Or if you use
a small number,  then use one of those directory entries  for a subdirec-
tory,  and put all the files there.   That way it doesn't matter how many
files you have on the |nRAMdisk|n.  The /E and /X and /A switches are used if
you want the |nRAMdisk|n  to be placed into extended or expanded memory.   Of
course you can only use one of them at a time.   The :D parameter that is
connected to  the /E or /X or /A is optional,  and it tells DOS  how many
                       <page down> for more RAMdisk
|ssector|ss of data to transfer to and from the |nRAMdisk|n at a time.  The D can
be from 1 to 8,  with 8 as the default,  and you can  pretty much  ignore
that |sparameter|s;  just leave it at the default,  unless the manual for one
of your applications tells you otherwise.

Just don't forget if you ever decide to remove the |nRAMdisk|n line from your
CONFIG.SYS file,  that all of the applications you may have configured to
use the |nRAMdisk|n for their temporary files,  will still be looking for the
|nRAMdisk|n,  and that could cause you big problems.   So remember everything
that you've told  to use the |nRAMdisk|n,  including batch files,  so in case
you stop  using the |nRAMdisk|n  you can direct  everything back to your hard
drive again.

You can use  as many RAMdisks as you want  at the same time,  if you have
enough memory, by repeating the DEVIC|1E command that creates the RAMdisks.
Each |nRAMdisk|n will get the next higher drive letter than the previous one.



                     <page down> for The |nMODE|n Command
                             The |TMODE|T Command

This command has  about a million uses.   This is going to be a long sec-
tion.   I think that  the most common use for it  is to change  the video
mode after some program  (usually a game) has messed it up.   If you exit
a program  and your screen has letters  that are twice their normal size,
or your screen is so messed up that you can't even tell you have a prompt
or cursor, try typing |nMODE|n CO80 (that's C-Oh-Eight-Zero) and hit <Enter>.
There, is that better?   That stands for COlor and eighty columns,  so if
you don't have a color monitor, use BW80 instead, because that stands for
Black and White and eighty columns.

If you have  trouble seeing  the little letters  on the screen,  try |nMODE|n
CO40  and see if  that helps.   Of course  most applications that you run
are going to set it back to CO80,  so you'll have to keep setting it back
to CO40 every time you exit back to DOS.   But a batch file can make that
easy on you.

If you have DOS version 4 or 5,  you can use  the |nMODE|n command  to change
                        <page down> for more MODE
your keyboard repeat rate.   You know when you hold a key down it is sup-
posed to zoom across the screen  typing that same letter or function over
and over again?   Well it doesn't "zoom" very well until you do something
to raise the repeat rate.   The version 4 |nMODE|n command can do that.  |nMODE|n
CON: RATE=## DELAY=# is what the command would look like  to perform that
function,  and you just need  to figure out what you want to use in place
of ##.   The DELAY= number means  how long you want  to have to hold down
the key before it  starts repeating.   You can use the numbers  1 through
4, and they represent quarter-seconds.   If you use DELAY=1, then if your
finger accidentally holds the key down for one quarter of a second, what-
ever letter you're holding down will start zooming across the screen.  If
you use DELAY=4 you'll have to hold the key down for a full second before
it will start repeating.  The RATE= parameter specifies approximately how
many times per second the key should repeat.  You can use any number from
1 to 32.   I use |nMODE|n CON: RATE=32 DELAY=2 in my AUTOEXEC.BAT file.   And
while this command is not a TSR, it does actually change one of the |sCPU|s's
registers,  so this change you make  with the |nMODE|n command will be effec-
tive in most of your applications, not just at the DOS command line.   Of
course some applications  might reset it,  so you would need  to reset it
                        <page down> for more MODE
again.  A batch file will make that easy for you.  If you find an applic-
ation that resets the keyboard repeat rate  (also called typematic rate),
then start that app from a batch file,  and have the |nMODE|n CON: command as
the last line  of that batch file,  so that your repeat rate  always gets
reset between the time you exit the app and the time you see your prompt.
Of course it's possible  that this command  won't affect your keyboard at
all.  It works on most systems, but not all.   Can't hurt to try, though.
The default values are RATE=20 and DELAY=2.   But if you change one,  you
have to specify both in the command.

You can use the |nMODE|n command to tell your printer how many characters per
line  and how many lines per inch to print.   Of course most applications
that are designed to do any printing will reset the printer, but what you
set with the |nMODE|n command  will work when you're in DOS,  with the PRINT,
COPY FILE PRN, or TYPE FILE > PRN commands.   |nMODE|n LPT#:N,M,P is the for-
mat  for this function  of the |nMODE|n command.   LPT# means which port your
printer is attached to.  N means how many characters per line, 80 or 132.
M means how many lines per inch, 6 or 8.  The P you will probably want to
leave out.  It means that if the printer tells the CPU it's busy, the CPU
                        <page down> for more MODE
will keep trying to send more data anyway.  This is called continuous re-
try.  If you do use the P and your system seems to hang up, you can BREAK
out of it  with <Ctrl-C>  or <Ctrl-Break>.   (The system will not respond
right away, though, it will take maybe half a minute.)   This form of the
|nMODE|n command should only be used with Epson-compatible printers.   If you
have DOS version 4 or later, this form of the command has changed.   |nMODE|n
LPT#: COLS=N LINES=M RETRY=P  is what it's  like now.   The old form will
still work just fine, but if this form is easier for you, then use it in-
stead.

If you have DOS version 4.0 or later,  and you have ANSI.SYS installed in
your CONFIG.SYS file,  and you have an EGA or VGA display, then you might
use the |nMODE|n command to set your screen to 43 or 50 lines instead of just
25.  |nMODE|n CON: COLS=M LINES=N would do it, where M can be 40 or 80, and N
can be 25 or 43,  or if you have a VGA, then N could also be 50.   And if
you install ANSI.SYS  with an /L switch,  it will even try  to force your
applications to display  in this higher number  of lines per screen,  and
leave the display  in this mode  when you  exit back to DOS,  although it
won't work for all applications.
                        <page down> for more MODE
You can also use |nMODE|n to set the parameters for your COM1 or other serial
port.   Here's an example of the most common setting for this function of
the |nMODE|n command:   |nMODE|n COM1:2400,N,8,1,P  where COM1 refers to the comm
port you're trying to set parameters for.  2400 is the baud rate, N means
no parity, 8 means 8 data bits per byte, 1 means 1 stop bit,  and P means
continuous retry for when you're using a serial printer.  The choices for
port number are 1 or 2 for DOS 3.2 or earlier, or 1 through 4 for DOS 3.3
or later.  Baud can be 110, 150, 300, 600, 1200, 2400, 4800, or 9600, de-
pending on the rate supported by your modem and the modem you'll be call-
ing, and the conditions of the phone lines from here to there.   DOS ver-
sion 3.3 adds a rate of 19200 to those choices.  Parity can be None, Odd,
or Even.  Data bits can be 7 or 8, stop bits can be 1 or 2, and the P can
be there or not.  For DOS version 4, of course this form of the |nMODE|n com-
mand changed too.  |nMODE|n COM#: BAUD=B PARITY=Y DATA=D STOP=S RETRY=P.  Now
you're probably thinking that this form of the command is only for modems
but that's not the case!   In fact, it is rarely used for modems, because
most people use  specialized communications software to work with the mo-
dem, and it sets the parameters for them.   This form of the |nMODE|n command
is more often used for serial printers and mice and such things.
                        <page down> for more MODE
If you have  a serial printer instead of a parallel printer,  you need to
use the |nMODE|n command to tell DOS  to send whatever data it would normally
send to LPT1,  to your serial port instead.   This command's  syntax is a
lot easier  than some of the other forms of the |nMODE|n command.   It's like
this:   |nMODE|n LPT1:=COM#:  where # is the number  of the serial port  your
printer is connected to.   But first you have to use  the other |nMODE|n com-
mand above to tell your serial port what parameters to use.   Yes, that's
right, the difficult one with the baud rate,  parity,  stopbits,  and all
that.   But your printer manual should tell you  exactly which parameters
to use so you shouldn't have to  figure it out by yourself.   If you want
to put the printer output back to LPT1, then |nMODE|n LPT1: will do that.  If
you want to redirect |sLPT1|s's output to another parallel port, like LPT3 or
something, sorry but |nMODE|n can't do that.  You'll need a shareware or pub-
lic domain program from your local BBS.

While most functions  of the |nMODE|n command  do not involve  loading a TSR,
some do.   If you see the message  "Resident portion of |nMODE|n loaded",  it
means  that you did  use one of  the functions  of the |nMODE|n command  that
loads |nMODE|n as a TSR.
                    <page down> for The |nPRINT|n Command
                            The |TPRINT|T Command

This command is used to send a copy of a file to your printer.   It's the
very oldest example  of a multitasker under DOS,  because it works in the
background  to keep on  printing your file,  even after it has  given you
back your DOS prompt and you have begun working on something else!

Bear in mind though, that this is not the only way to print a file!   You
can use the COPY FILENAME PRN command  or the TYPE FILENAME > PRN command
just as well.  They don't take up any memory.   Of course they don't give
you back the DOS prompt either,  until they've sent the whole file to the
printer's buffer.   So for short files, use one of those.  But for a long
file  that you want to print  without waiting  for it to finish,  use the
|nPRINT|n command.

The DOS version 4 installation program  puts this command right into your
AUTOEXEC.BAT file.   If you don't use it very often, and if you don't use
the Print option within the DOSSHELL,  then you want to remove |nPRINT|n from
your AUTOEXEC.BAT  because it's  taking up  a lot of memory  for nothing.
                        <page down> for more PRINT
The same thing goes for the GRAPHICS command.

This is not the complete syntax of the |nPRINT|n command,  but it's about the
only important parts.   Hardly anybody  ever uses  the other parts so I'm
not going to confuse you with them:
          |nPRINT|n /D:PORT /Q:## /C /T D:\DIR\FILENAME.EXT

The first time you use this command after the last time you |sreboot|sed,  it
loads itself  into memory as a TSR.   It also wants to know what port you
intend for it  to print to.   It will  ask you,  and it will  fill in the
blank with PRN.   If PRN is the port  you want to use,  then you just hit
<Enter>.   Otherwise,  you type the name of port you do want to use,  and
hit <Enter>.   If you want to avoid  having |nPRINT|n ask you  that question,
then you include  the /D:PORT switch  right on the command line  with the
|nPRINT|n command,  as in  |nPRINT|n /D:LPT1  or |nPRINT|n /D:COM2,  or wherever your
printer is attached.  Now that's the port that the |nPRINT|n command is going
to use from then on,  until you reboot  the computer.   You can't use the
/D:PORT  switch  again to  change it  to something else.   If you want to
change it, you have to reboot and start the |nPRINT|n TSR all over again.
                        <page down> for more PRINT
Now the |nPRINT|n TSR is installed into memory, and the print |nqueue|n is empty.
(The print |tqueue|t is the internal list  where the |nPRINT|n command stores the
names of the files that you've told it to print, that haven't been print-
ed yet.)   Or if you did  put the filename  on the command line  when you
loaded the TSR into memory,  then that file goes right into the |nqueue|n and
starts printing.   Now if you think of another file  you'd like to print,
you just give another |nPRINT|n command with that second filename on the com-
mand line,  and that file will be  added to the |nqueue|n  (that's pronounced
just like  the letter Q,  by the way),  and when  the first file  is done
printing, |nPRINT|n will look at the |nqueue|n and print any files that are there
waiting to be printed.  The |nqueue|n can hold up to ten filenames at a time.
If you need to be able  to |nqueue|n up more files  than that at a time,  you
can use the /Q:## switch on the command line, but only the first time you
issue the command.   If you've already loaded  the |nPRINT|n TSR into memory,
then you have to reboot  before you can issue a command like  |nPRINT|n /Q:20
to enlarge the |nqueue|n.  Any number up to 32 is allowed there.

If your printer dies or if the paper gets all jammed up, you can just say
|nPRINT|n /T and that terminates the printing  and removes all the files from
                        <page down> for more PRINT
the queue.  (However, it doesn't remove the |nPRINT|n TSR from memory.)   Now
you can fix the printer or the paper, and start over.  Remember that your
printer contains a small buffer of memory  where it stores data that it's
about to print.  When you use |nPRINT|n /T to terminate printing, the printer
won't stop until it prints what's already in its own buffer,  even though
|nPRINT|n immediately stops sending new data to the printer.

If you just decide  there's one file  that you had  already  put into the
print queue,  that you don't  want to print after all,  you can remove it
from the print queue with the command  |nPRINT|n /C D:\DIR\FILENAME.EXT which
will cancel that file from the queue.

You can also use  wildcards with this command.   That means you could put
all the files  that start with  PB and have the extension  .TXT  into the
queue with just one  |nPRINT|n PB*.TXT command.   The names of the files that
match that wildcard specification will be displayed on the screen, and if
you realize  that you didn't mean to include  a couple of those,  you can
remove those from the queue with the /C switch.

                        <page down> for more PRINT
And you can put  more than one file  into the queue  at a time  by typing
each filename on the command line,  for example just one command:   |nPRINT|n
C:\DOS\README.TXT C:\DOS\APPNOTES.TXT would print those two files.

If you have DOS version 2, then you can only print files from the current
directory of any drive.  If you want to print a file from some other dir-
ectory, you have to use the CHDIR command to make that directory current,
and then you can use the |nPRINT|n command to add that file to the queue.

If you want  to see what files  are left in the queue  at any time,  just
issue the |nPRINT|n command with no parameters.

If you've ever heard the term "print |tspooler|t" and wondered what it meant,
the |nPRINT|n command  is just a  primitive example  of a print |nspooler|n.   It
means a little TSR utility  that keeps sending data  to the printer while
you go ahead and use the computer for something else.

Just like  the TYPE command,  |nPRINT|n will ignore  any data  in a file that
occurs after the first ^Z character.
                   <page down> for The |nRECOVER|n Command
                           The |TRECOVER|T Command

This is a command  you want to  be very careful with.   In fact you might
want to remove it from your disk,  or RENAME it to  DESTROY or something,
so that you don't ever forget how dangerous it is and use it by accident.

What it's supposed to be used for,  is to retrieve one file at a time, no
more than  one at a time,  from a disk  that has been damaged.   You see,
when part of a file is sitting in a disk |ssector|s that's gone bad, DOS just
won't do anything with any part of that file.   Well, the way to get back
all the readable parts is with the |nRECOVER|n command.  The syntax is:
          |nRECOVER|n D:\DIR\FILENAME.EXT
and as usual,  if the file in question is in the current directory of the
current drive,  you can leave that part out and say |nRECOVER|n FILENAME.EXT.
This will cause DOS to take the readable parts of the file and stick them
into a file  (either with the same name,  or with the name  FILE0000.REC,
depending on your DOS version) in the root directory of the disk in ques-
tion.  It will also mark the |sbad sector|ss as "unusable" in the FAT so that
DOS never tries to stick any more data in that spot.  So, now what do you
                       <page down> for more RECOVER
do with it?   Well, if it used to be a .COM or .EXE file, you're going to
delete it.   It's got  a chunk missing  out of the middle,  where the bad
|ssector|s was,  so there's no telling  what it might do  to your computer if
you try to run it.   (But don't just delete it  instead of RECOVERing it!
Because if you  |nRECOVER|n it first,  then the bad sector  will be marked as
bad in the FAT so DOS will never try to put a file into that spot again.)
If it was a word processor or spreadsheet file,  on the other hand, well,
at least you got  most of it back,  right?   It's better than  losing the
whole file.   You just have some work to do,  to put it back to its prev-
ious shape.   (If you kept a BACKUP like you're supposed to, you wouldn't
have such problems.)

All right, that's fine,  it sounds like it will work for just one file at
a time.   But if you have a floppy disk  that's a total wreck and a whole
bunch of files are giving  "Data error reading drive A:" messages and you
are sure that the problem is not just a drive that needs cleaning, do you
have to use the |nRECOVER|n command on every file separately?  Well, it's not
a bad idea.  It's a heck of a lot more sensible than RECOVERing the whole
disk.   You can't use wildcards with this command.  Your only choices are
                       <page down> for more RECOVER
one file at a time, or the whole disk at a time.   And RECOVERing a whole
disk at a time  is just about  the silliest thing you could  possibly do,
unless the directory itself is what has the |sbad sector|ss.

If you really have a disk with hardly anything but |sbad sector|ss, the first
thing you should do is make a DISKCOPY of it and try to |nRECOVER|n the copy,
not the original.  That way, if the recovery operation is a big flop, you
can take the original and start over,  only this time take it to a friend
who has PC Tools or the Norton Utilities running.

Next,  use XCOPY with the /S switch to get all the data you can from that
disk, onto some other disk, then whichever files get copied successfully,
delete those from the damaged disk.  And if the copying and deleting emp-
tied any subdirectories on the disk,  then RMDIR them.   That way,  there
won't be so many files left on the disk to get mixed up.   Now,  the only
files left on the disk  are the damaged ones,  so |nRECOVER|n and then delete
each of the .COM and .EXE files too, because even if you |nRECOVER|n them you
won't be able to use them,  for the reason stated above.   Now all that's
left is the data files that need to be recovered.
                       <page down> for more RECOVER
If you have  a disk where the directory structure itself  is what has the
|sbad sector|ss,  you won't  be able to access  any files on the disk at all.
First,  make a DISKCOPY of it,  and then use  the |nRECOVER|n command  on the
copy.   Or if you have a backup copy of the disk,  just trash the damaged
one and forget about the |nRECOVER|n command.

To |nRECOVER|n a whole disk, the syntax is |nRECOVER|n D: and that's all there is
to it.   All the files  on the whole disk,  including the  subdirectories
themselves,  will be  RECOVERed  and you'll end up  with a root directory
full of nothing but  FILE####.REC files,  because that's what the |nRECOVER|n
command will name them.   FILE0001.REC, FILE0002.REC, etc.   If there are
too many files  to fit in the  root directory  (remember that  there is a
limit to the number of entries allowed  in any root |sdirectory|s),  the com-
mand will stop,  and you should  COPY the .REC files  to another disk and
delete them from the damaged disk, and enter the |nRECOVER|n command again so
it can finish the rest of the disk.   Then comes the hard part,  figuring
out which FILE####.REC file is supposed to have what name.

If you ever accidentally use the |nRECOVER|n command on a disk when you meant
                       <page down> for more RECOVER
to use RESTORE instead,  or if you just didn't know  what horrible things
|nRECOVER|n would do to your files, then do not pass GO, do not collect $200,
just go straight to  PC Tools or the Norton Utilities  or if you have DOS
version 5, the UNFORMAT command.   If it's a floppy disk, make a DISKCOPY
of it first though,  in case the Utilities don't work the first time, you
can start over on the copy.

There's one other thing  the |nRECOVER|n command is useful for,  though.   If
you have a floppy disk  from which you want to  ERASE all the files,  but
the disk has  subdirectories on it,  you would have to  delete all of the
files from one subdirectory,  RMDIR the directory,  delete the files from
the next subdirectory,  remove it, etc,  and then delete all the files in
the root directory.   Well there is  an easier way,  if you're absolutely
positive that you want that whole disk erased.   |nRECOVER|n A:  will put all
the files  into the  root directory,  and convert  the subdirectories  to
files,  and put them in the  root directory too,  so that DEL A:\*.* will
remove everything  from the whole disk  (except the volume label).

If you  ever see  the error message  "|tSector not found|t",  a bad sector is
                       <page down> for more RECOVER
probably the cause of it  and |nRECOVER|n  is the cure  if you don't have the
Norton Utilities or PC Tools.  See the section about the NUL device for a
method of finding out  which file is the culprit  if your program doesn't
tell you which one it is.















                   <page down> for The |nREPLACE|n Command
                           The |TREPLACE|T Command

This command is good especially for updating  to a new version of a soft-
ware package.   With the /U switch,  it will take all the files  from the
source disk that have the same names,  but later dates, than the files on
the target disk.   Then you can use it  one more time  with the /A switch
instead of the /U,  to add all the files that are on the source disk that
don't exist on the target disk.  Pretty easy, huh?

Here's the complete syntax:
          |nREPLACE|n D:\DIR\FILENAME.EXT D:\DIR\ /A /P /R /S /U /W
where the first D:\DIR\ is where the source files are, and the second D:\
DIR\ is where you want the files to go.  Here are the switches:

The /A switch makes |nREPLACE|n add the files  that exist on the source disk,
that do not exist on the target disk.  This is the switch you want to use
after you've already run the |nREPLACE|n command with the /U switch.  This is
also the switch you want to use  if all you want to do is copy files that
do not exist already on the target disk.  Very handy!   But it only works
                       <page down> for more REPLACE
in the specified target directory.   In other words, you can't use the /S
switch with the /A switch.

The /P switch makes |nREPLACE|n pause and ask for permission before each file
it copies.

The /R switch  makes |nREPLACE|n update  even the files that have their Read-
only attributes turned on.   Only it doesn't set  the R attribute for the
file after it writes it, you have to do that yourself if you want the new
version of the file to have its R attribute set.

The /S switch  causes |nREPLACE|n  to search subdirectories  of the specified
target directory,  for files that need to be updated.   It doesn't search
subdirectories of the source directory, though, just the target.  Now you
want to be careful with this switch, because there might be a file in one
of the subdirectories,  that has the same name as one of the files on the
source disk, but that has no relation to the program you're updating.  If
so, that file will be overwritten by the file on the source disk that has
the same name.  It's also useful if you have more than one copy of a cer-
                       <page down> for more REPLACE
tain file  on your disk,  in different subdirectories,  and you receive a
newer copy of that file.   If you're sure that all the files  on the disk
that have that name,  are the same file  and you want  them all  replaced
with the new version, use the root directory as the target and use /S.

The /U switch  makes |nREPLACE|n work  only with files that have a later date
and time on the source disk than the date on the target disk.  That means
you won't replace a newer file  with an older file.   This switch did not
exist until DOS version 4, though.

The /W switch  makes |nREPLACE|n stop for a second  and let you change disks,
between the time you enter the command and the time it will start looking
for files to copy.   That's for if you have  the |nREPLACE|n.EXE file  on one
disk,  and the source files on some other disk of the same size,  you put
the disk that contains |nREPLACE|n.EXE into the drive, enter the command with
the /W switch,  and it will let you take out the |nREPLACE|n.EXE disk and put
in the source disk instead, and then it will start copying.

So what you usually want to do  is run the |nREPLACE|n command  once with the
                       <page down> for more REPLACE
/A switch and once with the /S and /U switches, for each directory on the
source disk that contains files you want to have updated.   If the source
files are all in just one directory,  then you only need to use those two
commands one time each, to update the whole program.

You're probably wondering  what use this command is,  when you could just
use  the XCOPY command  to copy them all with just one command?   Well if
the target files  are in different directories,  like maybe  C:\WORD  and
C:\WORD\DOCS and C:\WORD\LTRS and C:\WORD\NOTES, and all the source files
are in one directory  on the A: drive,  for example,  then a command like
XCOPY A:*.* C:\WORD  would put all the files  into the C:\WORD directory,
even if some of them belong  in some of those  subdirectories  of the C:\
WORD directory.   The |nREPLACE|n command  will look to see where you already
have each file,  and put the later copy  of each file into the right sub-
directory.  The only problem is, files that exist on the source disk that
didn't exist on the target disk,  will all be put into the same directory
on the target disk, unless you fiddle with the /P switch a lot.

Ok, that's not exactly the only problem.   The |nREPLACE|n command, like most
                       <page down> for more REPLACE
commands,  will not copy Hidden files,  nor those that have  their System
attributes set.   But for programs  that don't use  any of those types of
files,  and that don't have their own installation routines,  this can be
a very helpful command.

There's one thing you need to be careful of though,  when using REPLACE's
/U switch!   Since it works according to  the date and time stamps in the
directory entries,  then if your clock,  or the clock in the system  that
created the files you're installing, is wrong or has been wrong, then you
could end up overwriting new files with older files, or not replacing old
files that should have  been replaced!   The |nREPLACE|n command can only as-
sume that the date and time stamps are correct, and so it acts according-
ly.   It doesn't know any better.   Keep your system clock set right, and
take a look at the dates  of the source files  before you use the |nREPLACE|n
command, and make sure they look kosher.




                   <page down> for The |nRESTORE|n Command
                           The |TRESTORE|T Command

This is  the command  that you must use  in order to get  your files back
from your floppy disks  after you've backed them up.   The BACKUP command
puts all the files it backs up into one great big file, so |nRESTORE|n is the
only way you'll ever see those files again, if your hard drive dies.

The syntax of the |nRESTORE|n command is like this:
          COMMAND SOURCE TARGET SWITCHES
just like most DOS commands.  So let's discuss those parts one at a time.

The command is |nRESTORE|n, but like any external command, if the |nRESTORE|n.COM
file is neither in the current directory nor in a directory on your PATH,
then you'll have to specify the entire |spath|sname to the command as part of
the command.  That means you might say C:\DOS\RESTORE instead of |nRESTORE|n.

The source is  the drive where the files are,  that you want to have res-
tored to the hard drive.  Usually just A: or B:.

                       <page down> for more RESTORE
The target is where you want the files to end up.  If you want to restore
the entire hard drive,  then the target would be C:\*.*.   If you want to
restore only the files that start with BR in the \BROWN subdirectory, the
target would be C:\BROWN\BR*.*.  (See also Wildcards.)  Or if you want to
restore just the AUTOEXEC.BAT file,  the target would be C:\AUTOEXEC.BAT.

The hardest part  to figure out,  about the |nRESTORE|n command,  is that the
filenames and  the directory structure  are stored as  part of the backup
disks,  and that's the way  they get restored.   If you used to keep your
word processing program  in a directory named  \WORD,  back when you made
the backup disks, and nowadays you keep it in a directory named \WP, then
if you use the command  |nRESTORE|n A: C:\WP\*.*  then the |nRESTORE|n command is
going to give you a nasty error message like "No files found to restore",
because you didn't have any files named \WP\*.*  at the time you made the
backup disks.   Those files used to be called  \WORD\*.* instead.   So in
order to restore them,  you'll have to use |nRESTORE|n A: C:\WORD\*.* and the
|nRESTORE|n command will create a directory  called C:\WORD and put the files
there,  and then you'll have to use the COPY command to put them into the
\WP directory,  then delete the files from the  \WORD directory and RMDIR
                       <page down> for more RESTORE
the \WORD directory.  Restoring those files to D:\WORD wouldn't have been
a bit of a problem though.  Different drive but same directory, is ok.

So,  what switches are available with the |nRESTORE|n command?   Quite a few:
          /S   /P   /N   /M   /A:date   /B:date   /L:time   /E:time
The /S switch  tells DOS to also restore  the files in the subdirectories
of the  target directory.   If you had a directory named  C:\WORD\LETTERS
below your C:\WORD directory,  and you used C:\WORD\*.*  as the target of
the |nRESTORE|n command,  then if you leave out  the /S switch,  the files in
C:\WORD\LETTERS  will not be restored,  or if you include  the /S switch,
then they will be restored.  If you want to restore all the files on your
entire hard drive, then you always have to specify the /S switch, as well
as using C:\*.* as your target.

The /P switch tells DOS to pause and ask you  for confirmation every time
it encounters any files  that either have  their Read-only attributes set
on the target drive,  or that have a more recent copy on the target drive
than the copy on the backup disk.  In most cases, if the copy on the tar-
get drive is newer than the copy on the backup disk, then you probably do
                       <page down> for more RESTORE
not want |nRESTORE|n to overwrite  the newer copy with the older copy.   How-
ever, if you know that the newer copy on the target drive has been ruined
in some way, then yes, you do want to restore the older copy.

The /N switch only came into existence with version 3.3 of DOS,  and it's
about time!  This switch will find all the files that exist on the backup
disks, that no longer exist on the target disk.  That means if you delete
a bunch of files accidentally,  you can just restore them from the backup
disks without going through a complete restore!   There is one very small
problem with this,  however.   If you have |sRENAME|sd a file  since you made
the backup,  the /N switch of |nRESTORE|n will find that the file  (under its
old name)  no longer exists  on the target disk  (because it now has some
other name)  so it will restore that file.   So now you have the old copy
of the file, under its old name, as well as the |ncurrent|n copy of the file,
under its new name.   That's a waste of hard disk space!   So be sure and
check for this sort of thing whenever you use the /N switch with |nRESTORE|n,
and delete the old copies of |sRENAME|sd files.

The /M switch  does the same thing as the /N switch,  and more!   It also
                       <page down> for more RESTORE
restores any files that have been changed since the backup was made.   It
will replace  the more recent copy of the file,  with the old out-of-date
copy.   This is useful  for when you've made  some sort of a big goof and
messed up all your hard drive's data files,  and you need to get back the
old copies from before you did that.

The next four switches are all new with version 3.3 of DOS,  and they all
have to do with time.   The /A switch will restore all the files from the
backup disks that have a date that's the same or later  than the date you
specify with the /A:date switch.   The /B switch  will restore all of the
files whose date is the same or earlier than the date you specified.  The
/L:time and /E:time switches  must only be used with the /A or /B switch.
/L means files that have the same time  or a later time  than the one you
specify,  and /E means files whose time is  the same or earlier  than the
one you specified.

Before version 3.3 of DOS, the BACKUP command backed up the Hidden Files,
which are  IO.SYS and MSDOS.SYS for MS-DOS,  or IBMBIO.COM and IBMDOS.COM
for PC-DOS,  so that if you upgraded  to a new DOS version,  and then you
                       <page down> for more RESTORE
needed to restore some files  from your old backup disks,  you would have
to be very careful to see that |nRESTORE|n didn't try  to put your old Hidden
files back on the disk, right over top of the ones from your new DOS ver-
sion!   If you still have version 3.2  or an earlier version,  then watch
out for this.   But of course now that  Microsoft is selling  DOS version
5.0 right to the public,  instead of only to computer dealers, there's no
reason for you to stick with an old version.  DOS 5 is fantastic!

Many previous  versions  of the DOS  |nRESTORE|n command  could only  restore
files  that were made  by the BACKUP command  from that same DOS version.
But not DOS 5.0!  It can restore backup files from DOS 2.11 or later.

There is also a new switch for the DOS 5 |nRESTORE|n command.   The /D switch
will show you what files will be restored by the command you are entering
but it will not  restore any files.   Use the command  with the /D switch
first, as a test,  and if it shows you the right filenames, you enter the
same command again, only without the /D switch, to restore them.


                    <page down> for The |nSELECT|n Command
                            The |TSELECT|T Command

In version 3  of DOS,  this command  has to do with  code page switching.
The DOS version 4 |nSELECT|n command  is the installation program  which puts
DOS 4 onto your hard drive,  and since DOS 5 was released three weeks ago
I'm sure  no one is going  to buy a new copy of  the old version 4,  so I
won't waste your time on this one.












                    <page down> for The |nSHARE|n Command
                            The |TSHARE|T Command

This is a TSR that you need to load every time you boot up, if you are on
a Network or if you are using DOS version 4 and you have one or more hard
drive |spartition|ss of a size over 32 mega|sbytes|s.  I mean it, if you have any
logical drives that are larger than 32 megs and you are using DOS version
4.0 then you have got to load |nSHARE|n or really terrible things will happen
to your data.   This is not an idle threat.   DOS didn't really and truly
learn how to deal with  these large drives  until version 5,  although in
version 4  it became possible  to have them that big.   |nSHARE|n is the only
thing that makes it safe to have  those large |spartition|ss under version 4.

It's easy  to make |nSHARE|n load itself  every time you boot up.   Just make
sure the |nSHARE|n.EXE  file is located in the  same directory  that contains
your COMMAND.COM file,  and DOS will load it automatically.   Or,  if for
some reason that's not working,  then put  |sINSTALL|s=C:\DOS\SHARE.EXE  into
your  CONFIG.SYS file and that will definitely load it.   Of course, then
make sure  the |nSHARE|n.EXE file  is in the C:\DOS directory  where you told
CONFIG.SYS it was at.
                        <page down> for more SHARE
Now if you have DOS version 4  and a large hard drive partition,  and DOS
doesn't find the |nSHARE|n.EXE file in order to load it,  it'll give you this
error message:  "Warning!   |nSHARE|n must be loaded for large media".   (The
type of disk  you're using is what |tmedia|t means.)   You can also use |nSHARE|n
from the AUTOEXEC.BAT file,  but if you do,   you will still receive that
error message, because that message comes up before the AUTOEXEC.BAT file
gets read,  so DOS will just think that you were planning to skip loading
|nSHARE|n.  Besides, if something that comes earlier in AUTOEXEC.BAT than the
|nSHARE|n command, is something that writes to the disk, then you're in trou-
ble since |nSHARE|n has not been loaded yet.   So it's really best to use one
of the other methods to load |nSHARE|n.

Another thing that |nSHARE|n does in version 4,  is it checks the serial num-
ber on your floppy disk before it allows anything to be written to it, to
make sure you didn't change disks.   That way,  DOS won't trash the flop-
py's FAT by writing info that was supposed to go on one disk,  to another
disk, after you changed disks without DOS realizing it.

But on the other hand,  another thing that |nSHARE|n does is to refuse to let
                        <page down> for more SHARE
you do a bunch of things you might want to do.  It thinks it's protecting
your hard drive,  but sometimes it just  gets a little carried away.   So
when I  first got DOS 4  and an 85 meg hard drive,  I only used |nSHARE|n for
about three days before I got fed up  and decided to use  FDISK to repar-
tition my drive into smaller logical drives, so that I didn't need to use
|nSHARE|n anymore.   You might end up doing the same thing.   Then again,  if
you just get DOS version 5, you can have a partition as large as you want
without needing |nSHARE|n.

Now one thing  that hardly anybody  ever remembers.   If you need to load
|nSHARE|n every time you boot, then the |nSHARE|n.EXE file also has to be located
on every copy of every  floppy disk you ever boot from.   Having |nSHARE|n in
the right directory on your hard drive  to make DOS load it automatically
during |sboot|sup,  doesn't do a bit of good  when you're |sboot|sing from floppy
disk.   Put |nSHARE|n.EXE into the same directory with COMMAND.COM,  on every
disk you ever boot from.



                    <page down> for The |nSUBST|n Command
                            The |TSUBST|T Command

This is a command that's kind of dangerous (although it's certainly safer
than |sASSIGN|s), but it does have its uses if you follow the rules.

It is used to make a directory pretend like it is a drive.   For example:
          |nSUBST|n G: C:\WORD\DOCS\LTRS\JOHN
After you enter that command you can reference the C:\WORD\DOCS\LTRS\JOHN
directory by simply typing G:.

Of course for that command to work  you have to use the LASTDRIVE command
in your CONFIG.SYS file to tell DOS you'll be needing a G: drive.  If the
highest drive letter  you already have is D:,  then you want to say some-
thing like |nSUBST|n E: C:\WORD\DOCS\LTRS\JOHN  instead of using G:, and then
you'll only need to say |sLASTDRIVE|s=E, instead of G, in CONFIG.SYS.

To cancel a SUBSTitution  and put things  back to normal,  |nSUBST|n G: /D or
|nSUBST|n E: /D  will do it.   To display a list of SUBSTitutions you have in
effect, type |nSUBST|n all by itself, with no parameters.
                        <page down> for more SUBST
There are a bunch of commands  that are unsafe for use  with any |nSUBST|n in
effect:  ASSIGN, BACKUP, CHKDSK,  DEL, DISKCOMP, DISKCOPY,  ERASE, FDISK,
FORMAT, LABEL, JOIN, MIRROR, RECOVER, RESTORE, and SY|1S.

So why would anybody  want to use a command  that gives problems  with so
many other DOS commands?   Well there are quite a few times  when this is
useful.   For one thing,  if you find that your PATH environment variable
is too long,  and you don't have time right now to reorganize your entire
hard drive  or write batch files so you can shorten it,  you can do |nSUBST|n
E: C:\WORD and |nSUBST|n F: C:\UTIL  and replace C:\WORD with E:\ and C:\UTIL
with F:\ on your PATH command  in your AUTOEXEC.BAT file,  and that saves
you 8 characters.   But that is not a permanent solution to the 127-char-
acter limit for the PATH variable!   Use batch files or DOSKEY macros in-
stead of a long PATH.

What if you have an application such as an old version of WordStar,  that
doesn't know anything about |spath|snames and stuff?   You can trick WordStar
into using subdirectories by saying  |nSUBST|n E: C:\WORD\DOCS and then tell-
ing WordStar to pull up a file from your E: drive.
                        <page down> for more SUBST
And then  there's always the reason of  just plain laziness.   It's a lot
easier to type E:  than it is to type C:\WORD\DOCS\LTRS\JOHN.   But in my
opinion that is nowhere near  a good enough reason  to use such a danger-
ous command!

You can also do something like this:
          |nSUBST|n A: C:\TEMP
for programs that insist on using drive A: when you want them to use your
hard drive.   After you issue that command, whenever the program requests
something from drive A:,  DOS will give it something from the TEMP direc-
tory of drive C: instead.

Or for programs  that want drive A:,  and you made the mistake  of buying
the program  on the wrong size disks,  and you can only  use them in your
B: drive,  and the program won't work because  it wants drive A:,  and oh
my, what are you going to do?   Try |nSUBST|n A: B:\ and see if it works.  It
has the same effect as ASSIGN A=B but it's much safer.

Of course,  you can't use your A: drive while one of these commands is in
                        <page down> for more SUBST
effect,  because whenever you tell DOS something about A:,  it will think
you're talking about C:\TEMP or B:\ or whatever is SUBSTituted for A:.

Now if you have some application  that requires you to use the |nSUBST|n com-
mand  because that app doesn't understand  about subdirectories, then you
want to only run that app from a batch file  that makes the SUBSTitution,
runs the program,  and then cancels the SUBSTitution between the time you
exit the app  and the time you get your  DOS prompt back.   That way, you
don't have  to worry  about those commands  that |nSUBST|n is not  compatible
with,  because the only time |nSUBST|n will be active is while you're running
that application that needs it.   But if shelling out to DOS is something
that program allows,  then if you do so,  don't forget  to stay away from
those commands that |nSUBST|n doesn't like!






                     <page down> for The |nTREE|n Command
                             The |TTREE|T Command

This command  just shows you a sort of a list  of all the directories and
subdirectories you have on your disk.  Here's the syntax:
          |nTREE|n D:\DIR /F /A
where D:\DIR  is the drive and part of the directory tree  where you want
to start the listing.   Before version 4, you couldn't say the directory,
just the drive, for which you want the tree display.  In version 4 if you
don't specify  any |spath|sname,  it will start the display  with the current
directory instead of the root the way older versions did.   The /F switch
says you want  to see the names  of all the files  under each  directory.
And the /A switch, starting with version 4, lets you use a slightly diff-
erent character set  for the display,  in case your printer  doesn't like
the normal one.  That will make it use things like + and -- and || to draw
the lines with.   Of course,  to get the display to your printer, you use
output redirection, as in:
          |nTREE|n C:\ /F > PRN


                 For beginning of File 4, see CONFIG.SYS
|tAUTOEXEC.BAT|t|fSIMPLY1|f
|TFASTOPEN|T|fSIMPLY1|f
|TFAT|T|fSIMPLY1|f
|tUNFORMAT|t|fSIMPLY1|f
|tXCOPY|t|fSIMPLY1|f
|tBatch|t|fSIMPLY2|f
|tRedirection|t|fSIMPLY2|f
|TREM|T|fSIMPLY2|f
|tANSI.SYS|t|fSIMPLY4|f
|tbad sector|t|fSIMPLY4|f
|TBREAK|T|fSIMPLY4|f
|TBUFFERS|T|fSIMPLY4|f
|tCONFIG.SYS|t|fSIMPLY4|f
|tDevice Driver|t|fSIMPLY4|f
|TDEVIC|1E|T|fSIMPLY4|f
|tEnvironment|t|fSIMPLY4|f
|TFDISK|T|fSIMPLY4|f
|tfloppy|t|fSIMPLY4|f
|TFORMAT|T|fSIMPLY4|f
|TGRAPHICS|T|fSIMPLY4|f
|tIBMBIO.COM|t|fSIMPLY4|f
|tIBMDOS.COM|t|fSIMPLY4|f
|TINSTALL|T|fSIMPLY4|f
|tinterrupt|t|fSIMPLY4|f
|tIO.SYS|t|fSIMPLY4|f
|TJOIN|T|fSIMPLY4|f
|TLABEL|T|fSIMPLY4|f
|TLASTDRIVE|T|fSIMPLY4|f
|tLogical Drives|t|fSIMPLY4|f
|tmacros|t|fSIMPLY4|f
|TMIRROR|T|fSIMPLY4|f
|tMSDOS.SYS|t|fSIMPLY4|f
|tpartition|t|fSIMPLY4|f
|tPATH|t|fSIMPLY4|f
|tPROMPT|t|fSIMPLY4|f
|tvolume|t|fSIMPLY4|f
|TC|1:|T|fSIMPLY5|f
|TCHDIR|T|fSIMPLY5|f
|TCLOCK$|T|fSIMPLY5|f
|tCode Page|t|fSIMPLY5|f
|TCOM1|T|fSIMPLY5|f
|tCOMMAND.COM|t|fSIMPLY5|f
|TCOMMAN|1D|T|fSIMPLY5|f
|TCON|T|fSIMPLY5|f
|TCOPY|T|fSIMPLY5|f
|tcurrent|t|fSIMPLY5|f
|tdefault|t|fSIMPLY5|f
|TDEL|T|fSIMPLY5|f
|tDevice|1s|t|fSIMPLY5|f
|tDirectory|t|fSIMPLY5|f
|TDIR|T|fSIMPLY5|f
|TERASE|T|fSIMPLY5|f
|TEXIT|T|fSIMPLY5|f
|texternal|t|fSIMPLY5|f
|TLPT1|T|fSIMPLY5|f
|TNUL|T|fSIMPLY5|f
|TPRN|T|fSIMPLY5|f
|TRENAME|T|fSIMPLY5|f
|TRMDIR|T|fSIMPLY5|f
|troot|t|fSIMPLY5|f
|tShelling Out|t|fSIMPLY5|f
|TTIME|T|fSIMPLY5|f
|TTYPE|T|fSIMPLY5|f
|TVERIFY|T|fSIMPLY5|f
|TBBS|T|fSIMPLY6|f
|tbinary|t|fSIMPLY6|f
|tBoot|t|fSIMPLY6|f
|tBoo|1t Disk|t|fSIMPLY6|f
|tCleaning|t|fSIMPLY6|f
|tcluster|t|fSIMPLY6|f
|tcommercial|t|fSIMPLY6|f
|tDisks|t|fSIMPLY6|f
|tKeyboard|t|fSIMPLY6|f
|tParameters|t|fSIMPLY6|f
|tPower|t|fSIMPLY6|f
|tpublic domain|t|fSIMPLY6|f
|tReboot|t|fSIMPLY6|f
|tsector|t|fSIMPLY6|f
|tShareware|t|fSIMPLY6|f
|TSY|1S|T|fSIMPLY6|f
|tWildcards|t|fSIMPLY6|f
|TAPPEND|T|fSIMPLY7|f
|TASSIGN|T|fSIMPLY7|f
|tAttributes|t|fSIMPLY7|f
|TBACKUP|T|fSIMPLY7|f
|TCHKDSK|T|fSIMPLY7|f
|TDISKCOMP|T|fSIMPLY7|f
|TDISKCOPY|T|fSIMPLY7|f
|TDOSKEY|T|fSIMPLY7|f
|TDOSSHELL|T|fSIMPLY7|f
|tfragmented|t|fSIMPLY7|f
|tHidden|t|fSIMPLY7|f
|toptimizer|t|fSIMPLY7|f